Aller au contenu
English

Fraude par carte avec un budget de révision

  • Étude de cas 1
  • 150 min
  • Facultative · 1 étude de cas requise pour le certificat

Où nous en sommes

Dans ce cours, nous avons trouvé les fraudes insérées de Larkfield avec des règles, des scores robustes, l'isolement, un autoencodeur et un modèle de reclassement. Le tout respectait un budget de révision. Maintenant, nous essayons la même méthode sur un jeu publié de paiements par carte avec ses propres étiquettes. Dans cette étude de cas, nous comparons des références de base, des détecteurs sans étiquettes et un modèle supervisé. Nous choisissons selon le coût par semaine, avec un budget quotidien.

Étude de cas 1 sur 4 · Détection d'anomalies : trouver ce qui est inhabituelFraude par carte avec un budget de révision
Aperçu du cours

Ce que vous saurez faire

Transformez un an et demi de paiements par carte en une file de révision quotidienne justifiée par des chiffres. Vous verrez pourquoi l’exactitude ne dit rien ici. Vous construirez des variables à partir du passé de chaque carte. Vous comparerez des références de base, deux détecteurs sans étiquettes et un modèle supervisé, avec un seul budget et une seule mesure. Ensuite, vous en choisirez un, le testerez une fois et l’exécuterez sur un mois qu’il n’a jamais vu.

Étude de casPièce de portfolio

Licence
CC0 1.0
Durée
Environ 2,5 h
S’exécute dans
Colab, Kaggle ou VS Code
Compétences utilisées
  • Le piège du taux de base
  • Variables tirées du passé d'une carte
  • Découpage chronologique
  • Précision au budget fixé
  • Coût par semaine
  • Isolation Forest et kNN
  • Boosting par gradient
  • Classement selon la perte attendue

Les carnets sont en anglais. Colab et Kaggle ouvrent votre propre copie. Pour utiliser VS Code, téléchargez le carnet depuis GitHub. Vous êtes bloqué ? Consultez le carnet de solution.

Le carnet (notebook) Jupyter exécute chaque étape de cette page, avec le même code et les mêmes sorties. Il contient aussi trois tâches avec des vérifications. Ses cellules de préparation installent pandas et scikit-learn et téléchargent les données (21,5 Mo). Il ne nécessite aucun compte ni aucune configuration locale. Son exécution prend environ une minute après l’installation.

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

Ce que vous devez savoir

Cette étude de cas utilise l’ensemble du cours. Ces leçons sont les plus importantes :

Ce qu’il vous faut sur votre ordinateur

Rien : le carnet s’exécute dans Colab ou Kaggle. Pour l’exécuter localement, utilisez un environnement virtuel avec Python 3.12, pandas 3.1.1, NumPy 2.5.4 et scikit-learn 1.9.1. La cellule de préparation crée un dossier anomaly-course. Pour recommencer, supprimez ce dossier.

Testé sur macOS avec Python 3.12, dans Jupyter après un démarrage à neuf. Colab, Kaggle, Windows et Linux n’ont pas été testés.

Imaginez un petit émetteur de cartes : une banque qui fournit des cartes à environ mille clients. Chaque jour, ses clients font environ 2 500 paiements avec leurs cartes. Quelques paiements sont frauduleux : un criminel utilise un numéro de carte volé.

Farah dirige l’équipe de révision. Son équipe peut vérifier soigneusement 20 alertes par jour : appeler le client, bloquer la carte au besoin. Kofi, un scientifique des données, doit décider quels 20 paiements l’équipe voit chaque jour. Nous avons inventé Farah, Kofi et la banque pour cette étude de cas. Les paiements viennent d’une simulation publiée, décrite ci-dessous.

Chaque alerte a un coût, tout comme chaque fraude que personne ne révise. L’étude de cas utilise les coûts du cours, qui sont des hypothèses :

  • Une fraude manquée coûte son montant, plus des frais de rétrofacturation de 15 $ : le coût pour la banque lorsqu’un client conteste un paiement.
  • Une fausse alerte coûte 3 $, soit environ 4 minutes du temps d’un réviseur.

Farah demande à Kofi : « Quels 20 paiements mon équipe devrait-elle examiner chaque jour? Et combien votre choix nous fait-il économiser? »

Vous construirez une file de révision quotidienne : chaque jour, les 20 paiements que l’équipe devrait examiner en premier. Vous comparerez une règle simple, deux détecteurs sans étiquettes et un modèle supervisé entraîné sur des fraudes passées. Tous respectent le même budget, avec la même mesure : le coût par semaine des fraudes manquées et des fausses alertes. Vous testerez ensuite votre choix une fois. Puis vous l’exécuterez sur décembre 2020, un mois avec deux fois plus de paiements que d’habitude.

Les données viennent du Credit Card Transactions Fraud Detection Dataset de Kartik Shenoy sur Kaggle. Il contient 1 852 394 paiements par carte du 1er janvier 2019 au 31 décembre 2020. Chaque paiement porte une étiquette : fraude ou non.

Les paiements sont simulés. Kartik Shenoy les a créés avec le générateur Sparkov de Brandon Harris. Le générateur invente des clients, des commerces et des habitudes de dépenses, puis ajoute la fraude d’une façon fixe. Aucune ligne ne représente une personne ou une carte réelle.

Pourquoi pas le célèbre jeu de données sur la fraude?

Section intitulée « Pourquoi pas le célèbre jeu de données sur la fraude? »

La plupart des tutoriels sur la fraude utilisent les données de fraude par carte de l’ULB. Ce sont des paiements réels de titulaires de cartes européens. Nous avons vérifié leur licence : l’Open Database License avec la Database Contents License, qui ajoute des conditions de partage à l’identique. Les données de ce cours ont des conditions plus simples : domaine public, CC0, CC BY 4.0, MIT et Apache-2.0. D’autres cours de Nextia utilisent des données sous partage à l’identique (CC BY-SA) ou sous CC BY 3.0, chacune selon ses propres conditions. Ce jeu couvre aussi seulement deux jours et ne contient aucun identifiant de carte. Il ne permet donc ni un budget quotidien sur plusieurs semaines ni un historique par carte. Nous avons choisi un jeu simulé sous licence ouverte. Nous indiquons clairement où une simulation peut être trompeuse.

Voici les colonnes utilisées dans l’étude de cas :

Colonne Signification
ts La date et l’heure du paiement.
card_id La carte, de K-0001 à K-0999. Nous avons remplacé les numéros de carte simulés.
category Le type de commerce, par exemple grocery_pos (en magasin) ou shopping_net (en ligne). Il y en a 14.
amount Le montant, en dollars.
is_fraud 1 pour une fraude, 0 pour un paiement honnête.
gender, birth_year Des renseignements simulés sur le titulaire de la carte. Nous les utilisons seulement pour vérifier l’équité des alertes, jamais comme entrées du modèle.
tx = pd.read_csv("data/card_transactions.csv.gz", parse_dates=["ts"])
day = tx.ts.dt.floor("D")
print(f"{len(tx):,} transactions, {tx.card_id.nunique()} cards, {day.min():%Y-%m-%d} to {day.max():%Y-%m-%d}")
print(f"fraud: {tx.is_fraud.sum():,} ({tx.is_fraud.mean():.2%}) | cards with fraud: {tx[tx.is_fraud == 1].card_id.nunique()}")
print(f"missing values: {tx.isna().sum().sum()} | repeated rows: {tx.duplicated().sum()} | amount from {tx.amount.min()} to {tx.amount.max():,}")
print("days with no payment:", [f"{d:%Y-%m-%d}" for d in pd.date_range(day.min(), day.max()).difference(day.unique())])
1,852,394 transactions, 999 cards, 2019-01-01 to 2020-12-31
fraud: 9,651 (0.52%) | cards with fraud: 976
missing values: 0 | repeated rows: 0 | amount from 1.0 to 28,948.9
days with no payment: ['2020-02-29']
mean min 50% max
transactions 2537.5 1073.0 2306.0 6530.0
fraud 13.2 0.0 12.0 50.0

Ce que cela nous apprend. Les données sont propres : aucune valeur manquante et aucune ligne répétée. Il manque une journée, le 29 février 2020 : le simulateur saute le jour bissextile. Une journée compte environ 2 540 paiements et 13 fraudes. Le budget de 20 dépasse donc le nombre moyen de fraudes. Mais certains jours comptent 50 fraudes, et d’autres aucune.

fraud episodes: 976 | payments per episode: median 10 (from 2 to 19) | days per episode: median 1.9
fraud between 22:00 and 03:59: 84.6% | all payments: 23.5%
median amount ($): {'honest': 47.24, 'fraud': 390.0}

Un épisode regroupe toutes les fraudes sur une carte. Ici, chaque carte touchée par la fraude a exactement un épisode : environ 10 paiements en environ 2 jours. La plupart des fraudes se produisent tard la nuit et leurs montants dépassent ceux des paiements honnêtes.

  • Fraudes : part à chaque heure
  • Paiements honnêtes : part à chaque heure
Les paiements honnêtes se répartissent sur la journée. Les fraudes se concentrent à 22 h et 23 h, et restent nombreuses jusqu'à 3 h 59.
Description textuelle du graphique

Deux lignes sur les 24 heures de la journée. Les paiements honnêtes forment une ligne presque plate : environ 3,3 % par heure de minuit à 11 h. Puis environ 5 % par heure de midi à 23 h. Les fraudes sont rares le jour, sous 1,2 % par heure de 4 h à 21 h. Elles montent ensuite à 25,7 % à 22 h et à 25,3 % à 23 h. Elles restent entre 8,2 % et 8,6 % par heure de minuit à 3 h.

Ce que cela nous apprend. C’est un simulateur, et sa fraude suit un schéma net. La fraude réelle est moins régulière. Un détecteur peut apprendre les habitudes du simulateur, par exemple « tard la nuit signifie fraude ». Les chiffres de cette page montrent donc comment comparer et choisir. Ils ne montrent pas à quel point une méthode fonctionne dans une vraie banque.

Pensez à un détecteur de fumée qui a raison 99 % du temps. Cela semble très bon. Mais dans une année, une cuisine compte des milliers de moments de cuisson et un seul véritable incendie. Si le détecteur sonne pendant 1 % des moments de cuisson, il sonne des dizaines de fois pour chaque incendie. Après un mois, personne ne le croit.

La même chose se produit avec la fraude. Le taux de base est la part des paiements frauduleux : ici, 0,6 % au premier semestre de 2020. Quand le taux de base est faible, même une minuscule part de fausses alertes sur les paiements honnêtes produit beaucoup d’alertes. C’est le piège du taux de base : un détecteur qui semble exact peut tout de même envoyer surtout des fausses alertes.

Un arbre. 10 000 paiements se divisent en 60 fraudes et 9 940 paiements honnêtes. Le détecteur trouve 90 % des fraudes : 54 vraies alertes. Il signale à tort 1 % des paiements honnêtes : 99 fausses alertes. Ensemble : 153 alertes, dont 54 fraudes, soit une précision de 35 %, même si l'exactitude atteint 98,95 %.
Un détecteur qui trouve 90 % des fraudes et signale seulement 1 % des paiements honnêtes. Avec un taux de base de 0,6 %, 65 % de ses alertes sont fausses.
Description textuelle du diagramme

Le diagramme commence avec 10 000 paiements, dont 0,6 % sont frauduleux, comme de janvier à juin 2020. Il les divise en 60 fraudes et 9 940 paiements honnêtes. À partir des fraudes, une flèche indique « le détecteur en trouve 90 % » et mène à 54 vraies alertes. Il reste 6 fraudes manquées. À partir des paiements honnêtes, une flèche indique « il en signale à tort seulement 1 % ». Elle mène à 99 fausses alertes. Les deux mènent à la dernière case : 153 alertes, dont 54 fraudes. La précision est de 35 %. L’exactitude est de 98,95 %, mais la plupart des alertes sont fausses.

Le carnet fait le même calcul sur les mois du jeu de données :

accuracy of 'nothing is fraud': 99.40%
per day: 13.4 frauds, 2,207 honest payments
alerts per day: 34.1 (12.0 real, 22.1 false) | precision 0.353 | accuracy 98.95%

Ce que cela nous apprend. « Rien n’est une fraude » donne une exactitude de 99,40 %, sans trouver la moindre fraude. Le détecteur qui semble bon envoie 34 alertes par jour à une équipe qui peut en examiner 20. Deux alertes sur trois sont fausses. Nous ne jugeons donc jamais un détecteur selon son exactitude. Nous le jugeons au budget de l’équipe : parmi les 20 paiements examinés chaque jour, combien sont frauduleux, et combien coûte le reste?

Kofi écrit ses réponses avant de construire un modèle :

  • Unité : un paiement. L’équipe révise les paiements, et les coûts sont par paiement.
  • Budget : 20 alertes par jour, une hypothèse. Chaque jour, l’équipe examine les 20 scores les plus élevés. Les égalités gardent l’ordre chronologique.
  • Une mesure pour choisir : le coût par semaine. Les fraudes manquées coûtent leur montant plus 15 $, et chaque fausse alerte coûte 3 $. La précision au budget fixé et le rappel l’accompagnent, comme dans Le budget d’alertes.
  • Ce qu’on sait au moment d’un paiement : seulement les paiements antérieurs de la carte. Chaque variable utilise uniquement le passé. L’étiquette d’un paiement arrive des semaines plus tard, quand le titulaire se plaint.
  • Colonnes sensibles : gender et l’âge restent exclus de tous les détecteurs. Ils servent seulement à la fin, pour vérifier les alertes groupe par groupe.

Un détecteur attribue toujours des scores au futur avec ce qu’il a appris dans le passé. Le découpage suit donc le temps, comme dans Données d’entraînement, de validation et de test :

Quatre cases en ordre chronologique. 2019, apprendre : 924 850 paiements, 5 220 fraudes. Janvier à juin 2020, choisir : 401 883 paiements, 2 419 fraudes. Juillet à novembre 2020, tester une fois : 386 123 paiements, 1 754 fraudes. Décembre 2020, nouvelles entrées : 139 538 paiements, 258 fraudes, avec un modèle réentraîné sur les étiquettes jusqu'au 31 octobre.
Apprenez sur 2019, choisissez sur le premier semestre de 2020, testez une fois sur juillet à novembre. Puis exécutez sur décembre comme nouvelles entrées.
Description textuelle du diagramme

Quatre cases de gauche à droite. La première est 2019, où les détecteurs apprennent : 924 850 paiements avec 5 220 fraudes. Les détecteurs sans étiquettes apprennent à reconnaître le normal, et le modèle supervisé apprend à partir des étiquettes. La deuxième est janvier à juin 2020, où Kofi compare les détecteurs et choisit : 401 883 paiements avec 2 419 fraudes. La troisième est juillet à novembre 2020, le test, utilisé une fois : 386 123 paiements avec 1 754 fraudes. Rien ne change après ce test. La dernière est décembre 2020, les nouvelles entrées : 139 538 paiements avec 258 fraudes. Le modèle utilisé est réentraîné sur les étiquettes jusqu’au 31 octobre.

Un paiement de 400 $ est normal pour une carte et étrange pour une autre. Ainsi, comme dans Les variables comptent plus que l’algorithme, chaque paiement est comparé au passé de sa carte. Kofi utilise quatre variables :

Variable Ce qu’elle mesure
log_amount Le montant du paiement (le logarithme, pour que 10, 100 et 1 000 $ forment des pas égaux).
hour L’heure de la journée.
log_spend_24h_vs_usual_day Les dépenses de la carte sur les dernières 24 heures, comparées à sa journée habituelle : la médiane de ses 30 derniers jours avec paiements.
night_payments_24h Les paiements de la carte entre 22 h et 5 h 59 au cours des dernières 24 heures.

La fonction card_features() du carnet les construit, avec trois colonnes supplémentaires pour la règle et les références de base. Chaque variable utilise seulement les paiements antérieurs de la carte, ou le paiement lui-même :

log_amount hour log_spend_24h_vs_usual_day night_payments_24h
honest 3.86 14.0 0.34 1.0
fraud 5.97 22.0 2.70 4.0

Ce que cela nous apprend. Ce sont les médianes. Une fraude typique est environ 8 fois plus élevée (5,97 contre 3,86 sur l’échelle logarithmique). Elle arrive un jour où la carte dépense environ 15 fois plus que d’habitude (2,70 sur l’échelle logarithmique). Et c’est le quatrième paiement de nuit en 24 heures. Un paiement honnête typique ne présente aucun de ces traits.

Kofi commence avec quatre scores simples. Chacun attribue un nombre à chaque paiement, et l’équipe examine les 20 plus élevés chaque jour :

  • Cote z : la distance entre le montant et la moyenne de tous les paiements de 2019. Une seule référence de base pour toutes les cartes (Cotes z).
  • Cote z robuste par carte : la distance entre le montant et la médiane de la carte, en unités de sa dispersion (l’écart interquartile ÷ 1,349, comme dans Médiane, MAD et IQR).
  • Règle : un paiement de nuit dont le montant est 3 fois le montant habituel de la carte. Elle donne 1 ou 0, donc les égalités gardent l’ordre chronologique.
  • Règle, avec classement : la même règle, mais les paiements qui dépassent le plus la limite passent en premier.

Sur les mois de validation, de janvier à juin 2020 :

Détecteur Alertes par jour Précision à 20 Rappel Coût par semaine ($)
Aucun détecteur 0 0 0 51 430
Cote z du montant 20 0,288 0,431 14 071
Cote z robuste par carte 20 0,144 0,215 33 095
Règle 114,6 0,063 0,094 47 627
Règle, avec classement 114,6 0,284 0,425 18 789

Ce que cela nous apprend. Ne rien faire coûte 51 430 $ par semaine : les fraudes ont des montants élevés ici. Examiner simplement les 20 plus gros montants chaque jour réduit ce coût à 14 071 $. La règle se déclenche 115 fois par jour, donc ses 20 premiers paiements en ordre chronologique sont surtout honnêtes. Avec classement, sa précision approche celle de la cote z, mais son coût est plus élevé. La cote z robuste par carte est la pire. Les montants d’une carte varient beaucoup, donc une réservation de voyage honnête semble extrême. De ses 3 099 fausses alertes, 1 138 sont dans la catégorie des voyages.

Ensuite, Isolation Forest et la distance kNN, avec les paramètres du cours dans Isolation Forest et Loin des voisins. Ils apprennent à reconnaître le normal à partir de 2019, et ne voient jamais d’étiquette :

forest_raw = IsolationForest(n_estimators=200, random_state=0).fit(X.loc[reference.index, ["log_amount", "hour"]])
forest = IsolationForest(n_estimators=200, random_state=0).fit(X.loc[reference.index, FEATURES])
scaler = StandardScaler().fit(X.loc[reference.index, FEATURES])
sample = np.random.default_rng(0).choice(len(reference), 20_000, replace=False)
neighbours = NearestNeighbors(n_neighbors=10).fit(scaler.transform(X.loc[reference.index, FEATURES])[sample])
Détecteur Précision à 20 Rappel Coût par semaine ($)
Isolation Forest, données brutes (montant et heure) 0,264 0,396 17 288
Isolation Forest, variables de la carte 0,370 0,554 16 203
Distance kNN, variables de la carte 0,302 0,451 29 971

Ce que cela nous apprend. Les variables de la carte aident Isolation Forest, comme dans le module 4 : la précision passe de 0,264 à 0,370. Il trouve plus de fraudes que la cote z. Mais il coûte plus par semaine : 16 203 $ contre 14 071 $. Sur les six mois, la file d’Isolation Forest contient 1 341 fraudes totalisant 897 586 $. Parmi elles, 157 sont sous 100 $. La cote z fait examiner les 20 plus gros montants chaque jour. Sa file contient moins de fraudes, 1 043, mais elles valent davantage : 958 086 $. Donc, sans étiquettes, trier par montant l’emporte sur le coût. La mesure que vous choisissez détermine le gagnant.

Kofi a des étiquettes : la banque sait quels paiements de 2019 étaient frauduleux. Il peut donc entraîner un modèle qui apprend à reconnaître la fraude. Il utilise le boosting par gradient, un ensemble de petits arbres de décision (HistGradientBoostingClassifier de scikit-learn). Ses entrées sont les quatre variables de la carte et la catégorie du commerce. Il apprend uniquement à partir de 2019 et ne voit jamais d’étiquette de 2020 :

def train(part):
model = HistGradientBoostingClassifier(max_iter=200, learning_rate=0.1, early_stopping=False,
categorical_features="from_dtype", random_state=0)
return model.fit(model_inputs(part), part.is_fraud)
model = train(reference) # labels of 2019 only
p_fraud = model.predict_proba(model_inputs(validation))[:, 1]
Détecteur Précision à 20 Rappel Coût par semaine ($)
Boosting par gradient, classé par probabilité 0,506 0,757 9 960
Parfait (connaît les réponses, montants les plus élevés d’abord) 0,595 0,891 1 423

Ce que cela nous apprend. Avec des étiquettes, le modèle dépasse largement tous les détecteurs sans étiquettes. Sa précision atteint 0,506 contre 0,370 pour Isolation Forest (forêt d’isolement). Son coût atteint 9 960 dollars par semaine contre 14 071 pour le montant. La ligne parfait montre le plafond. Les jours où il y a plus de 20 fraudes, même une file parfaite ne peut pas toutes les traiter. Les jours calmes, elle ne peut pas remplir 20 places avec des fraudes.

Le modèle donne une probabilité. Pourquoi ne pas envoyer tous les paiements au-dessus de 0,5?

threshold 0.5: 13.6 alerts a day (from 0 to 38), precision 0.758, recall 0.768
days with more than 20 alerts: 29 of 181
accuracy at 0.5: 99.71%

Un seuil fixe envoie un nombre différent d’alertes chaque jour : aucune certains jours, 38 d’autres jours. Pendant 29 jours, l’équipe en reçoit plus qu’elle ne peut en examiner. Beaucoup d’autres jours, ses places restent vides. Le budget maintient la file à 20, et c’est le seuil qui bouge, comme dans Le budget d’alertes.

Erreur courante

Les nouvelles cartes qui semblaient normales

Symptôme : dans une version précédente, le premier paiement d’une nouvelle carte obtenait une probabilité de fraude de 0. Il s’agissait de 1 100 dollars en ligne à 23 h 31. Le modèle faisait confiance à toutes les nouvelles cartes.

Cause : une carte sans passé n’a pas de « journée habituelle ». La première version comparait le paiement à lui-même. Le ratio était donc exactement 1 : « habituel ». En 2019, le premier jour d’une carte était presque toujours légitime. Les données commencent le 1er janvier 2019, et toutes les cartes commencent alors. En 2020, chaque carte qui apparaissait pour la première fois commençait par une fraude :

2019: 2,880 payments on a card's first day, 294 of them fraud
validation: 107 payments on a card's first day, 107 of them fraud

Correction : comparez une carte sans passé à une carte typique : le paiement médian et la journée-carte médiane de 2019. La nuit à 1 100 dollars d’une nouvelle carte semble alors inhabituelle, comme elle devrait l’être. La précision à 20 passe de 0,455 à 0,506. Le coût par semaine passe de 15 902 à 9 960 dollars.

Conséquence pour le travail en IA : « aucun historique » est une valeur, pas un vide à remplir avec n’importe quoi. Choisissez délibérément à quoi comparer un nouveau client, une nouvelle carte ou un nouvel appareil. Les équipes antifraude connaissent bien ce risque : la fraude commence souvent dans les nouveaux comptes.

Premier jour d'une nouvelle carte : 1 100 dollars en ligne à 23 h 31, sans paiements antérieurs. Comparée à elle-même, sa journée habituelle correspond à cette dépense. Le ratio vaut 1 et elle semble habituelle. Comparée à une carte typique de 2019, le ratio dépasse largement 1 et elle semble inhabituelle.
Le même paiement, deux valeurs par défaut. Comparée à elle-même, une nouvelle carte semble toujours habituelle. Comparée à une carte typique, elle peut sembler inhabituelle.
Description textuelle du diagramme

À gauche, une boîte : premier jour d’une nouvelle carte, 1 100 dollars en ligne à 23 h 31, sans paiements antérieurs. Une flèche mène à une question : comparer à quoi? Une branche indique « à elle-même » : la journée habituelle correspond à cette dépense, le ratio vaut 1 et le paiement semble habituel. Le modèle a appris de 2019 que les premiers jours sont légitimes. L’autre branche indique « à une carte typique de 2019 » : la journée habituelle correspond à une journée-carte typique. Le ratio dépasse largement 1 et le paiement semble inhabituel. Le modèle peut le signaler.

Le modèle indique la probabilité qu’un paiement soit frauduleux. Mais le coût pour Farah dépend du montant de chaque fraude. Imaginez un agent de sécurité à l’entrée d’un commerce qui a le temps de vérifier 20 sacs. Un sac contenant probablement un stylo volé importe moins qu’un sac pouvant contenir un ordinateur portable volé.

La perte attendue d’un paiement est son coût moyen si personne ne l’examine : probabilité de fraude × (montant + 15). Voici un petit exemple avec deux paiements :

Paiement P(fraude) Montant ($) Perte attendue ($)
A 0,90 20 0,90 × (20 + 15) = 31,50
B 0,50 900 0,50 × (900 + 15) = 457,50

Par probabilité, l’équipe examine A en premier. Par perte attendue, elle examine B en premier, car B risque de coûter environ 15 fois plus. Kofi classe les paiements du même modèle par perte attendue :

def expected_loss(part, p):
"""The money that a payment is likely to cost if nobody reviews it: P(fraud) x (amount + fee)."""
return p * (part.amount.to_numpy() + CHARGEBACK_FEE)
Boosting par gradient Précision à 20 Rappel Coût par semaine ($)
classé par probabilité 0,506 0,757 9 960
classé par perte attendue 0,500 0,749 6 077

Ce que cela nous apprend. Le même modèle, les mêmes 20 places par jour, presque la même précision. Mais le coût baisse de 39 %, de 9 960 à 6 077 dollars par semaine. L’équipe examine maintenant les grosses fraudes en premier. Ce classement exige une probabilité, donc seul le modèle supervisé peut bien le faire. Un détecteur sans étiquettes donne un score, pas une probabilité.

Tous les détecteurs sur les mois de validation, à 20 par jour :

De janvier à juin 2020, 20 alertes par jour. Le boosting par gradient classé par perte attendue coûte le moins cher. Sans étiquettes, trier par montant bat Isolation Forest, la règle et kNN.
Description textuelle du graphique

Un diagramme à cinq colonnes montre le coût par semaine à 20 alertes par jour, de janvier à juin 2020. « Modèle », le boosting par gradient classé par perte attendue : environ 6 000 dollars, le plus bas, dans la première couleur. La cote z du montant : environ 14 000. Isolation Forest sur les variables de la carte : environ 16 000. La règle classée : environ 19 000. La distance aux k plus proches voisins (kNN) : environ 30 000.

Kofi choisit le boosting par gradient sur les variables de la carte, classé par perte attendue. Son coût par semaine est le plus bas, et sa précision est proche de la meilleure. Il note deux autres options pour plus tard. La cote z (z-score) du montant est la solution de repli si les étiquettes cessent d’arriver. Isolation Forest trouve plus de fraudes que le montant, mais elles sont plus petites.

Kofi exécute maintenant chaque détecteur sur juillet à novembre 2020, une seule fois, sans rien changer ensuite :

Détecteur Précision à 20 Rappel Coût par semaine ($)
Parfait (le plafond) 0,528 0,921 802
Boosting par gradient, perte attendue 0,431 0,753 4 421
Boosting par gradient, probabilité 0,432 0,753 7 307
Cote z du montant 0,245 0,428 11 224
Isolation Forest, variables de la carte 0,330 0,575 12 543
Isolation Forest, données brutes 0,221 0,386 14 417
Règle, classée (127,2 alertes par jour) 0,224 0,390 16 689
Distance aux k plus proches voisins (kNN), variables de la carte 0,256 0,446 25 696
Cote z robuste par carte 0,121 0,211 27 728
Règle (127,2 alertes par jour) 0,048 0,084 40 200
Aucun détecteur 0 0 43 245
De juillet à novembre 2020, utilisés une seule fois. L'ordre est le même que sur les mois de validation. Le modèle choisi coûte 4 421 dollars par semaine, environ le dixième du coût de l'inaction.
Description textuelle du graphique

Un diagramme à cinq colonnes montre le coût par semaine à 20 alertes par jour, de juillet à novembre 2020. « Modèle », le boosting par gradient classé par perte attendue : environ 4 000 dollars, le plus bas, dans la première couleur. La cote z du montant : environ 11 000. Isolation Forest : environ 13 000. La règle classée : environ 17 000. La distance aux k plus proches voisins (kNN) : environ 26 000.

Ce que cela nous apprend. Le choix tient. L’ordre des détecteurs est le même que sur les mois de validation. La précision baisse un peu pour chaque détecteur, de 0,500 à 0,431 pour le modèle choisi. Le taux de base passe en effet de 0,60 % à 0,45 %. La file choisie manque 434 fraudes en cinq mois. Leur montant médian n’est que de 20,46 dollars. La file laisse passer les petites fraudes et attrape les grosses, dont le montant médian est de 748,08 dollars.

Farah demande si ajouter des réviseurs serait rentable. Le carnet (notebook) Jupyter fait varier le budget sur les mois de validation :

  • Boosting par gradient, perte attendue
  • Cote z du montant
  • Parfait
Mois de validation. Le coût du modèle choisi baisse rapidement jusqu'à environ 30 alertes par jour. Il atteint son minimum à 40 (3 026 dollars par semaine), puis remonte lentement. À 80 et 100 par jour, la simple cote z coûte moins cher.
Description textuelle du graphique

Trois courbes montrent le coût par semaine selon le budget, de 5 à 100 alertes par jour. Le modèle choisi : 27 568 dollars par semaine à 5, 15 222 à 10, 6 077 à 20, 3 348 à 30, 3 026 à 40 (le minimum), 3 322 à 60 et 4 033 à 100. La cote z du montant : 45 083 à 5, 14 071 à 20, 6 372 à 50 et 3 013 à 100. La file parfaite, en pointillés : 1 423 à 20, 436 à 30 (son minimum) et 1 819 à 100.

Ce que cela nous apprend. Passer de 20 à 30 alertes par jour réduirait le coût de 6 077 à 3 348 dollars par semaine. C’est presque la moitié. Au-delà de 40 par jour, les alertes supplémentaires sont surtout fausses, et le coût remonte. Une surprise : à 80 ou 100 alertes par jour, trier par montant coûte moins cher que le modèle. Avec autant de places, l’équipe examine tous les gros paiements, et les grosses fraudes concentrent l’argent perdu. Le meilleur détecteur dépend donc du budget. Choisissez-les ensemble.

La dernière étape applique le modèle choisi à de nouvelles entrées : décembre 2020. Les étiquettes de novembre ne sont pas encore complètes, car les rétrofacturations prennent des semaines. Kofi réentraîne donc le modèle sur les étiquettes jusqu’au 31 octobre, puis calcule un score pour chaque paiement de décembre :

detector setting alerts per day precision at budget recall cost per week ($) false alerts per week
no detector nothing is reviewed 0.0 0.000 0.000 32744 0.0
z-score |z| of the amount 20.0 0.140 0.337 14101 120.4
Isolation Forest card features; fit on 2019 20.0 0.195 0.469 12839 112.7
gradient boosting trained on 2019; expected loss 20.0 0.279 0.671 5653 100.9
gradient boosting retrained to 2020-10-31; expected loss 20.0 0.281 0.674 4854 100.7
perfect knows the answers; largest first: the ceiling 20.0 0.400 0.961 573 84.0
December: 4,501 payments a day (2020 before December: 2,359), 8.3 frauds a day

Ce que cela nous apprend. Décembre compte presque deux fois plus de paiements que d’habitude, et moins de fraudes. Le taux de base descend à 0,18 %, soit le tiers de celui des mois de validation. La précision baisse donc pour chaque détecteur, même le parfait (0,400). Le modèle réentraîné fait quand même examiner 67 % des fraudes. Il coûte 4 854 dollars par semaine, contre 32 744 pour l’inaction. Le réentraînement a un peu réduit le coût, de 5 653 à 4 854. C’est encore le piège du taux de base, en production : la normale a changé, comme dans Quand le « normal » change.

Que voit l’équipe? Voici les 8 premières des 20 alertes du 22 décembre 2020, classées par perte attendue, avec les raisons présentées au réviseur :

2020-12-22: 6,123 payments, 7 frauds; the team's 20 alerts hold 5
ts card_id category amount amount_vs_usual night_payments_24h p_fraud expected_loss is_fraud
1813534 2020-12-22 20:57:17 K-0288 travel 11586.34 470.42 6.0 1.00 11601.34 0
1814016 2020-12-22 22:31:48 K-0999 shopping_net 1039.42 1.20 6.0 1.00 1054.42 1
1811588 2020-12-22 14:30:10 K-0999 shopping_net 997.77 21.05 3.0 1.00 1012.77 1
1814246 2020-12-22 23:13:39 K-0999 misc_net 766.38 0.88 7.0 1.00 781.38 1
1813872 2020-12-22 22:05:48 K-0999 shopping_pos 1041.51 1.20 4.0 0.55 578.73 1
1808739 2020-12-22 01:49:59 K-0094 misc_net 719.80 14.55 4.0 0.59 436.82 0
1808796 2020-12-22 02:03:38 K-0224 shopping_pos 682.38 15.25 5.0 0.60 417.83 0
1814204 2020-12-22 23:06:03 K-0999 grocery_pos 289.27 0.31 6.0 1.00 304.27 1

Ce que cela nous apprend. La première alerte est légitime : une réservation de voyage de 11 586 dollars, 470 fois le montant habituel de la carte. Un réviseur la confirme en un appel, pour 3 dollars. Les 5 fraudes de la file concernent une seule carte, K-0999, apparue pour la première fois le 21 décembre. Sa fraude a commencé dès ses premiers jours. La comparaison par défaut avec une carte typique l’a rendue visible. Une vraie équipe les regrouperait en une alerte par carte, comme dans Du score à l’alerte.

Kofi écrit à Farah dans ses mots à elle :

  • Chaque jour, examinez les 20 paiements ayant la perte attendue la plus élevée selon le modèle de boosting par gradient. Sur les mois de test, cela coûtait 4 421 dollars par semaine. C’est contre 43 245 sans révision, 11 224 pour « les 20 montants les plus élevés » et 12 543 pour Isolation Forest.
  • Réentraînez chaque mois sur les étiquettes complètes et surveillez la précision chaque semaine. En décembre, elle est passée de 0,431 à 0,281 parce que le taux de base a baissé. Le modèle n’était pas défaillant.
  • Demandez 10 révisions supplémentaires par jour. Sur les mois de validation, 30 alertes par jour réduiraient le coût de 6 077 à 3 348 dollars par semaine. À 3 dollars l’alerte, 10 alertes coûtent 210 dollars par semaine.
  • Traitez les nouvelles cartes de façon délibérée. Comparez-les à une carte typique et examinez leurs premiers jours avec une attention particulière.
  • Gardez la cote z du montant comme solution de repli. Elle n’exige aucune étiquette et était le détecteur sans étiquettes le moins cher.

Et voici à quoi ne pas l’utiliser :

  • Pas pour bloquer automatiquement les paiements. La file sert à la révision humaine. À 20 par jour, plus de la moitié de ses alertes concernent des clients honnêtes.
  • Pas comme preuve que cela fonctionne dans une vraie banque. Les données sont simulées, avec une fraude bien ordonnée. Refaites le test sur des données réelles avant toute décision.
  • Les étiquettes ont plus compté que l’algorithme. Isolation Forest et kNN n’ont jamais approché le modèle supervisé. Quand vous avez des étiquettes passées, utilisez-les. Gardez aussi un détecteur sans étiquettes pour les nouveaux types de fraude.
  • La mesure a décidé du gagnant. Pour la précision, Isolation Forest a battu la cote z du montant. Pour le coût, la cote z a gagné. Choisissez d’abord la mesure avec l’entreprise.
  • Le simulateur est bien ordonné. Un épisode par carte, une fraude surtout à 22 h et 23 h, chaque nouvelle carte commençant par une fraude. Un modèle peut apprendre ces tendances, qui ne tiendraient pas dans une vraie banque.
  • Le budget est une hypothèse. Nous avons choisi 20 par jour. Le meilleur détecteur changeait à 80 par jour.
  • Aucun délai dans les étiquettes, sauf en décembre. Dans la comparaison, nous avons supposé que toutes les étiquettes de 2019 étaient connues le 1er janvier 2020. Une vraie équipe reçoit les étiquettes des semaines plus tard.
  • Un paiement égale une alerte. Une équipe regrouperait les alertes d’une même carte. La leçon Du score à l’alerte du cours montre comment.
  • Vérifiez les alertes groupe par groupe. Le genre et l’âge des titulaires de cartes simulés ne sont jamais des entrées. Les alertes peuvent quand même toucher davantage un groupe, comme dans Tranches et équité. Sur les mois de test, la file choisie signale 47,9 paiements légitimes sur 10 000 pour les femmes. Elle en signale 42,1 pour les hommes. Selon l’âge, elle en signale de 39,4 (30 à 44 ans) à 50,6 (60 ans et plus). Elle trouve 69,8 % des fraudes sur les cartes des femmes et 81,6 % sur celles des hommes. Ces différences viennent des profils de dépenses du simulateur. Mais une vraie équipe doit les chercher, les expliquer et décider de ce qui est équitable. Biais et accessibilité, dans le cours Sécurité de l’IA, vie privée et conception responsable, montre comment.
  • Une fausse alerte concerne un vrai client. Elle signifie un appel, peut-être une carte bloquée pendant les vacances. Gardez une personne dans la décision et comptez les clients honnêtes bloqués séparément de l’argent.
  • N’entraînez pas le modèle sur des données personnelles inutiles. Nous avons retiré les noms, adresses et numéros de carte simulés, même s’ils sont fictifs. Faites de même avec les données réelles.
  • Citez les sources. CC0 ne demande rien, mais nommez Kartik Shenoy et le générateur Sparkov, et indiquez que les données sont simulées.

Cette étude de cas montre à un employeur que vous pouvez choisir un détecteur selon son coût pour l’entreprise. Vous ne vous limitez pas à un seul score. Elle montre aussi que vous pouvez trouver un piège caché dans les données et présenter honnêtement un résultat. Personnalisez-la avec un changement : d’autres coûts, des alertes regroupées par carte ou un deuxième modèle, par exemple. Puis publiez-la pour qu’une personne puisse la lire en cinq minutes.

Quoi mettre dans le dépôt :

  • README.md, la page que les gens lisent en premier (modèle ci-dessous).
  • Le carnet Jupyter, exécuté du début à la fin, avec ses sorties.
  • comparison.csv : chaque détecteur sur les mois de validation, et test.csv séparément, avec le budget et les coûts.
  • La source et la licence des données : la page Kaggle, CC0 1.0, « simulées avec Sparkov » et le SHA-256 du fichier utilisé.

Un modèle de README :

# A daily review queue for card fraud, chosen by cost
## Problem
A review team can check 20 card payments a day. A missed fraud costs its amount + $15,
a false alert $3 (assumptions). Which 20 payments should it read?
## Data and licence
"Credit Card Transactions Fraud Detection Dataset" (Kartik Shenoy, Kaggle), simulated with
Sparkov (Brandon Harris), CC0 1.0. 1.85 M payments, 2019-2020, 0.52% fraud. Simulated.
## Approach
Features from each card's past (spend vs usual day, night payments in 24 h). Time split:
learn 2019, choose Jan-Jun 2020, test Jul-Nov 2020, run Dec 2020. Compared at 20 a day:
amount z-score, robust z per card, a rule, Isolation Forest, kNN, gradient boosting.
## Results
Gradient boosting ranked by expected loss: $4,421 a week on the test months, against $11,224
for the 20 largest amounts and $43,245 for no review. Without labels, the amount z-score was
cheaper than Isolation Forest. December: the base rate fell to 0.18%, precision 0.43 -> 0.28.
## Limits
Simulated data with tidy fraud; budget and costs assumed; labels assumed on time.

Comment le décrire en entrevue, en deux phrases : « J’ai comparé neuf détecteurs de fraude avec un budget fixe de 20 alertes par jour, sur des données séparées chronologiquement, selon le coût hebdomadaire des fraudes manquées et des fausses alertes. Classer un modèle de boosting par gradient par perte attendue plutôt que par probabilité a réduit le coût d’environ 40 %, et j’ai trouvé et corrigé une valeur par défaut qui faisait paraître toutes les nouvelles cartes sûres. »

Pour aller plus loin :

Avant de l’exécuter, faites une prédiction. Avec 10 alertes par jour, la précision du modèle choisi sur les mois de validation dépasse-t-elle 0,500? Dans le carnet (notebook) Jupyter, à la section 12, calculez-la et placez-la dans precision_at_10.

Afficher la réponse
precision_at_10 = score_at_budget(validation, expected_loss(validation, p_fraud), "gradient boosting", budget=10)["precision at budget"]
0.674

Elle est plus élevée : 0,674. Avec moins de places, l’équipe examine seulement les paiements dont la perte attendue est la plus élevée. Une plus grande part de ces paiements sont frauduleux. Mais le coût par semaine passe de 6 077 à 15 222 dollars. De nombreuses fraudes attendent sans que personne les examine. La précision seule favoriserait le budget réduit, mais le coût montre que c’est le mauvais choix.

Vérifiez votre compréhension

« Rien n'est frauduleux » donne une exactitude de 99,40 % sur les mois de validation. Un détecteur trouve 90 % des fraudes et signale seulement 1 % des paiements légitimes. Pourtant, 65 % de ses alertes sont fausses. Expliquez ces deux résultats et dites ce que Kofi mesure plutôt.

Afficher la réponse

La fraude est rare : elle représente 0,6 % des paiements. Dire « aucune fraude » pour chaque paiement est donc correct pour les 99,4 % qui sont légitimes, mais ne détecte rien. Le détecteur signale 1 % des nombreux paiements légitimes, soit 22,1 par jour. C’est plus que les 90 % des rares fraudes qu’il détecte, soit 12,0 par jour. Deux alertes sur trois sont donc fausses, même si son exactitude atteint 98,95 %. C’est le piège du taux de base. Kofi évalue le détecteur selon le budget de l’équipe. Il examine la précision des 20 alertes traitées chaque jour, le rappel et le coût par semaine des fraudes manquées et des fausses alertes.

Vérifiez votre compréhension

Sans étiquettes, Isolation Forest a une précision à 20 supérieure à celle de la cote z du montant. Mais la cote z coûte moins par semaine. Que devrait utiliser Farah sans étiquettes, et pourquoi les deux mesures ne concordent-elles pas?

Afficher la réponse

Elle devrait utiliser la cote z (z-score) du montant. La décision concerne l’argent, et le coût par semaine le mesure. Sur les mois de validation, il atteint 14 071 dollars contre 16 203 dollars par semaine. Les mesures ne concordent pas parce que la précision compte les fraudes, et chaque fraude compte autant. Isolation Forest (forêt d’isolement) trouve plus de fraudes, mais beaucoup portent sur de petits montants. La cote z sélectionne les plus gros paiements, et les grosses fraudes représentent la majeure partie de l’argent. Avec des étiquettes, classer les résultats d’un modèle par perte attendue, probabilité × (montant + 15), combine les deux idées.

Vérifiez votre compréhension

Le premier modèle a attribué une probabilité de fraude de 0 au paiement de 1 100 dollars d'une nouvelle carte, à 23 h 31. Quelle était la cause, comment Kofi l'a-t-il corrigée et quelle leçon générale en tirer?

Afficher la réponse

Une nouvelle carte n’a aucun historique, donc aucune journée habituelle. La première version comparait le paiement à lui-même. Son ratio de dépenses était donc de 1, ce qui signifie « habituel ». En 2019, le premier jour d’une carte était presque toujours sans fraude. Toutes les cartes commencent le 1er janvier 2019, au début des données. Le modèle a donc appris que les premiers jours étaient sans risque. En 2020, chaque nouvelle carte commençait par une fraude. Kofi a plutôt comparé les cartes sans historique à une carte typique de 2019. La précision est alors passée de 0,455 à 0,506. La leçon : un historique manquant exige une valeur par défaut choisie délibérément pour sa signification. Le modèle apprend aussi de cette valeur.

Récapitulatif

  • L’exactitude ne dit rien quand la fraude représente 0,5 % des paiements. Comparez les détecteurs selon le budget de l’équipe, avec une seule mesure : ici, le coût par semaine.
  • Sans étiquettes, les 20 plus gros montants (14 071 dollars par semaine) coûtent moins qu’Isolation Forest (16 203) et kNN. Pourtant, Isolation Forest avait une précision plus élevée.
  • Avec les étiquettes du passé, le boosting par gradient (gradient boosting) sur les variables des cartes était le meilleur. Avec un classement par perte attendue, il coûtait 6 077 dollars par semaine sur les mois de validation. Il coûtait 4 421 dollars sur les mois de test.
  • Une carte sans historique était comparée à elle-même et semblait sans risque. La comparaison avec une carte typique a rendu visibles les fraudes sur de nouvelles cartes.
  • En décembre, deux fois plus de paiements et moins de fraudes ont réduit le taux de base à 0,18 %. La précision a baissé pour chaque détecteur.

Ensuite, la deuxième étude de cas : les défaillances dans les mesures de machines ou de serveurs. Les étiquettes y correspondent à des fenêtres temporelles, et non à des paiements.

Leçon suivante : Pannes dans les métriques de machines ou de serveurs