Aller au contenu
English

Découvrir les données de Larkfield

  • Leçon 4
  • 35 min
  • Module 1 : Ce que « inhabituel » veut dire

Où nous en sommes

Nous connaissons les types d'anomalies et les contextes. Jusqu'ici, les exemples de Larkfield étaient seulement des histoires. Dans cette leçon, nous ouvrons le carnet de configuration et chargeons chaque table de Larkfield. Nous lisons les règles des anomalies insérées et découvrons le tableau comparatif que chaque module du cours remplit.

Leçon 4 sur 38 · Détection d'anomalies : trouver ce qui est inhabituelDécouvrir les données de Larkfield
Aperçu du cours

Ce que vous saurez faire

Chargez chaque table de Larkfield et vérifiez que votre configuration fonctionne. Évaluez vos premiers détecteurs dans le tableau comparatif que tout le cours remplit. La qualité d’un détecteur dépend de ses données et de la façon dont vous l’évaluez.

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

Le carnet (notebook) Jupyter contient toutes les cellules de code, les tâches et les vérifications de cette leçon, avec les consignes. Ses cellules de configuration installent pandas, NumPy, SciPy, scikit-learn et matplotlib, puis téléchargent les données du cours (environ 17 Mo). Aucune configuration locale n’est donc nécessaire. Environ 25 minutes.

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 35 minutes

Ce que vous devez savoir

Ce qu’il vous faut sur votre ordinateur

  • L’option carnet (recommandée) : un navigateur et un compte Google gratuit pour Colab, ou un compte Kaggle gratuit. Rien à installer.

  • L’option locale : Python 3.12 et VS Code avec ses extensions Python et Jupyter. Créez un dossier, puis un environnement virtuel, et installez le noyau du carnet. Sur macOS et Linux :

    Fenêtre de terminal
    python3.12 -m venv .venv
    source .venv/bin/activate
    python -m pip install ipykernel

    Sur Windows (PowerShell) :

    Fenêtre de terminal
    py -3.12 -m venv .venv
    .venv\Scripts\Activate.ps1
    python -m pip install ipykernel

    Téléchargez le carnet depuis l’encadré ci-dessus : le lien GitHub propose un bouton de téléchargement. Ouvrez le carnet dans VS Code et choisissez le noyau .venv. La première cellule du carnet installe le reste.

Testé avec Python 3.12.13 dans Jupyter sur macOS, avec pandas 3.1.1 et NumPy 2.5.4. Les commandes Windows et Colab n’ont pas été testées.

Avant un match de soccer, l’arbitre entre sur le terrain. Il vérifie les buts, les lignes, le ballon et l’horloge. Rien de cela ne fait partie du match. Mais si un but a la mauvaise taille ou si l’horloge est brisée, chaque décision du match est fausse. Personne ne le remarque avant plus tard.

C’est la même chose pour un détecteur. S’il manque une journée de données ou si les scores sont dans le mauvais ordre, le détecteur affiche quand même un nombre. Rien ne déclenche d’erreur. Le nombre est simplement faux. Avant de créer un détecteur dans ce cours, vous vérifiez donc les données et le tableau des scores une fois, soigneusement. C’est le but de cette leçon.

  1. Ouvrez le carnet depuis l’encadré Faites cette leçon dans un carnet, en haut de cette page.
  2. Exécutez la première cellule de configuration. Elle installe les paquets et affiche une ligne par paquet, par exemple pandas 3.1.1.
  3. Si vous voyez d’autres versions, redémarrez le noyau, puis exécutez la cellule de nouveau.
  4. Exécutez la deuxième cellule de configuration. Elle télécharge les données dans un dossier anomaly-course/data et vérifie la somme de contrôle de chaque fichier. Elle télécharge aussi compare.py et features.py, le code partagé du cours. Ensuite, elle utilise anomaly-course comme dossier de travail. Les chemins ci-dessous commencent donc par data/.
  5. Vérifiez sa dernière ligne. Elle commence par Ready: (prêt) et indique les fichiers et leur taille.
  6. Exécutez la cellule des fonctions utilitaires. Elle charge pandas sous le nom pd, NumPy sous np et matplotlib sous plt. Elle définit aussi les fonctions utilitaires des cellules de vérification. Elle n’affiche rien.

La ligne Ready: ressemble à ceci :

Ready: payments.csv.gz (6.9 MB), customers.csv (1.2 MB), refunds_daily.csv (0.0 MB), refunds_agents.csv (0.5 MB), refunds.csv (0.6 MB), ticket_api_metrics.csv.gz (0.6 MB), ticket_api_logs.csv.gz (1.8 MB), ticket_api_events.csv (0.0 MB), orders.csv (0.0 MB), tickets_daily.csv (0.0 MB), calendar.csv (0.0 MB), sealed-key.txt (0.0 MB)

Une somme de contrôle est une courte empreinte d’un fichier. Si un seul octet du téléchargement est incorrect, l’empreinte change et la cellule s’arrête avec wrong checksum (somme de contrôle incorrecte). Supprimez alors le dossier anomaly-course et exécutez la cellule de nouveau. Si la cellule indique Could not download (téléchargement impossible), vérifiez votre connexion Internet. Dans Kaggle, activez aussi Internet (accès Internet) dans les paramètres du carnet.

La section 1 du carnet lit chaque table et affiche sa taille :

files = ["payments.csv.gz", "customers.csv", "refunds_daily.csv", "refunds_agents.csv", "refunds.csv",
"ticket_api_metrics.csv.gz", "ticket_api_logs.csv.gz", "ticket_api_events.csv", "orders.csv",
"tickets_daily.csv", "calendar.csv"]
tables = {name: pd.read_csv(f"data/{name}") for name in files}
for name, table in tables.items():
print(f"{name:<28}{len(table):>9,} rows {', '.join(table.columns[:6])}{' ...' if len(table.columns) > 6 else ''}")

La sortie :

payments.csv.gz 343,074 rows payment_id, ts, customer_id, account_type, region, amount ...
customers.csv 24,038 rows customer_id, account_type, region, first_payment, signup
refunds_daily.csv 640 rows date, orders, refunds, refund_rate
refunds_agents.csv 17,772 rows date, agent_id, orders, refunds, refund_amount
refunds.csv 9,923 rows refund_id, date, agent_id, order_id, region, amount ...
ticket_api_metrics.csv.gz 86,400 rows ts, requests, error_rate, latency_p95_ms
ticket_api_logs.csv.gz 137,013 rows ts, level, logger, message
ticket_api_events.csv 22 rows ts, kind, detail
orders.csv 2,181 rows date, channel, orders
tickets_daily.csv 2,184 rows date, channel, tickets
calendar.csv 819 rows date, weekday, holiday, is_holiday

Les tables forment quatre groupes. Chaque groupe correspond à un type de question et aux personnes qui la posent :

Quatre cases à gauche, chacune avec une flèche vers une question à droite. payments et customers, 343 074 paiements par carte de juin à novembre 2025 : ce paiement est-il frauduleux? Utilisés pour les références de base, la distance et l'isolement, les méthodes profondes, l'évaluation et la tâche. Les trois tables refunds, 21 mois de remboursements : le processus de remboursement a-t-il changé? Utilisées pour les cartes de contrôle, les tests de dérive et les vérifications d'affaires. Les trois tables ticket_api, 60 jours avec une ligne par minute : le service fonctionne-t-il mal? Utilisées pour les anomalies dans le temps et dans les journaux. orders, tickets_daily et calendar, deux ans avec une ligne par jour : le nombre d'aujourd'hui est-il inhabituel? Utilisés pour les anomalies dans le temps.
Les quatre groupes de tables de Larkfield et la question à laquelle chaque groupe répond dans le cours.
Description textuelle du diagramme

Le diagramme comporte quatre cases à gauche, chacune avec une flèche vers une question à droite. D’abord, payments et customers : 343 074 paiements par carte de juin à novembre 2025. Leur question : ce paiement est-il frauduleux? Ils servent aux références de base, aux méthodes de distance et d’isolement, aux méthodes profondes, à l’évaluation et à la tâche de détection. Ensuite, refunds_daily, refunds_agents et refunds : 21 mois de remboursements. Leur question : le processus de remboursement a-t-il changé? Ils servent aux cartes de contrôle, aux tests de dérive et aux vérifications d’affaires. Puis, ticket_api_metrics, ticket_api_logs et ticket_api_events : 60 jours du service de soutien, avec une ligne par minute. Leur question : le service fonctionne-t-il mal? Ils servent aux anomalies dans le temps et dans les journaux. Enfin, orders, tickets_daily et calendar : deux ans, avec une ligne par jour. Leur question : le nombre d’aujourd’hui est-il inhabituel? Ils servent aux anomalies dans le temps.

Tables Une ligne représente Responsable chez Larkfield
payments, customers un paiement par carte; un client Sofia, risques liés aux paiements
refunds_daily, refunds_agents, refunds un jour; un agent pour un jour; un remboursement Grace, responsable du soutien
ticket_api_metrics, ticket_api_logs, ticket_api_events une minute; une ligne de journal; une mise en production ou un changement Amira, développeuse
orders, tickets_daily, calendar un canal pour un jour; un jour Mei, ingénieure de données, est responsable des flux; Grace lit les nombres de billets de soutien

Les commandes et les billets quotidiens reprennent les mêmes nombres que dans le cours sur les prévisions. Les deux cours présentent donc le même Larkfield. Les paiements forment une table distincte, à leur propre échelle : environ 1 875 paiements par jour. La table des commandes compte environ 676 commandes par jour. Ne comparez jamais les deux.

La section 2 montre les 12 derniers paiements de la cliente C-01234, celle de la première leçon :

payments = pd.read_csv("data/payments.csv.gz", parse_dates=["ts"])
hook = payments[payments.customer_id == "C-01234"]
hook[["ts", "amount", "country", "device_id", "merchant_category"]].tail(12)

La sortie :

ts amount country device_id merchant_category
181950 2025-09-06 09:34:00 16.02 CA D-6674e29 kitchen
194430 2025-09-13 09:29:08 16.75 CA D-6674e29 kitchen
206782 2025-09-20 09:02:43 17.77 CA D-6674e29 kitchen
219181 2025-09-27 09:17:38 15.16 CA D-6674e29 kitchen
229857 2025-10-03 02:14:07 24.27 PT D-9f3e1a2 home
229859 2025-10-03 02:15:05 19.26 PT D-9f3e1a2 gift_cards
229860 2025-10-03 02:16:16 20.66 PT D-9f3e1a2 electronics
229861 2025-10-03 02:17:17 18.88 PT D-9f3e1a2 electronics
229862 2025-10-03 02:18:18 24.39 PT D-9f3e1a2 home
229863 2025-10-03 02:19:13 19.16 PT D-9f3e1a2 electronics
229864 2025-10-03 02:20:23 24.36 PT D-9f3e1a2 home
229865 2025-10-03 02:21:31 19.25 PT D-9f3e1a2 home

L’histoire de la première leçon se retrouve dans les données. Quatre paniers du samedi au Canada, sur un même téléphone, sont suivis de huit paiements au Portugal sur un nouvel appareil. Ces huit paiements arrivent à raison d’un par minute. Les nombres à gauche sont les numéros des lignes de la table. La ligne 229858 manque dans la liste parce qu’elle appartient à un autre client.

Ce que nous avons inséré : les règles, pas les réponses

Section intitulée « Ce que nous avons inséré : les règles, pas les réponses »

Les données sont synthétiques. Nous avons donc inséré chaque problème volontairement et les avons consignés dans un corrigé. Cette section du carnet décrit les règles de nos insertions, sans indiquer les lignes. Les nombres proviennent du corrigé :

Table Problèmes insérés Combien
payments Cartes volées : beaucoup de petits paiements en peu de temps, souvent dans un nouveau pays 262 épisodes, 2 558 paiements
payments Tests de cartes : un appareil essaie les cartes de nombreux clients avec de très petits paiements 52 épisodes, 2 007 paiements
payments Prises de contrôle de comptes : quelques paiements coûteux depuis le compte du client 209 épisodes, 406 paiements
refunds Le taux de remboursement augmente de 0,3 point et reste élevé; un agent rembourse beaucoup plus que les autres; les remboursements d’un agent se regroupent juste sous la limite d’approbation de 100 $; certains remboursements sont versés deux fois; le flux quotidien envoie des zéros pendant une journée voir le module 3
ticket-api Une fuite de mémoire lente; un pic d’erreurs après une mise en production; un changement de configuration voir les modules 5 et 6

Au total, 4 971 paiements sont des fraudes insérées, réparties en 523 épisodes. Un épisode est un événement de fraude : par exemple, les huit paiements au Portugal constituent un épisode.

Les données contiennent aussi des événements qui semblent inhabituels, mais qui sont honnêtes. Un bon détecteur les laisse passer. Nous les avons marqués pour que le cours puisse compter les fausses alertes qu’ils causent :

Normal, mais inhabituel Paiements marqués
Paiements de la nouvelle région, east (en service depuis le 1er septembre 2025) 21 795
Paniers fractionnés : une commande payée en plusieurs parties 13 223
Le premier paiement dans l’application Larkfield (paiement dans l’application depuis le 15 octobre 2025) 9 532
Commandes en gros de clients d’affaires 9 077
Vendredi fou, 28 novembre 2025 5 087
Appareils empruntés : un appareil qu’un client a utilisé une seule fois 3 299
Clients en voyage à l’étranger 703
Nouveau téléphone d’un client 346

Le corrigé se trouve dans le fichier data/sealed-key.txt, sous une forme emballée pour éviter de le lire par accident. Le fichier compare.py du cours le déballe pour évaluer un détecteur. Vous pouvez le déballer vous-même avec compare.reveal() : il sert à évaluer votre travail, pas à garder un secret. Mais une fois les réponses connues, vos scores ne montrent plus comment un détecteur se comporte sur des données jamais vues. Traitez-le comme les réponses à la fin d’un livre.

La section 4 additionne les commandes des trois canaux pour chaque jour dans une série appelée daily. Elle trace cette série avec les jours fériés :

orders = pd.read_csv("data/orders.csv", parse_dates=["date"])
daily = orders.groupby("date").orders.sum() # one total per day

Le graphique ci-dessous montre les mêmes totaux quotidiens :

Commandes quotidiennes de Larkfield, tous les canaux, selon la série quotidienne partagée. Le Vendredi fou et la vague de chaleur de juillet 2025 donnent les journées les plus élevées. Les deux sont normales. La journée manquante, le 19 octobre 2025, est invisible : la ligne relie la veille au lendemain.
Description textuelle du graphique

Le graphique montre les commandes de Larkfield pour chacun des 727 jours, du 1er avril 2024 au 29 mars 2026. L’axe va de 0 à 1 500. Des étiquettes indiquent les deux Vendredis fous et la vague de chaleur. La ligne monte et descend chaque semaine et reste plus élevée en été. La moyenne est de 676 commandes par jour. La journée la plus élevée est le 5 juillet 2025, pendant une vague de chaleur, avec 1 372 commandes. Le Vendredi fou produit chaque année un pic abrupt et étroit : 1 059 commandes en 2024 et 1 224 en 2025. Les journées les plus faibles sont à Noël. Une journée, le 19 octobre 2025, n’a aucune donnée, mais vous ne pouvez pas le voir. La ligne passe directement du 18 au 20 octobre.

Le graphique du carnet affiche le dernier Vendredi fou :

Black Friday 2025: 1224 orders

Le Vendredi fou est l’une des journées les plus élevées de chaque année. Seules quelques journées autour de la vague de chaleur du début de juillet 2025 sont plus élevées. Le 5 juillet compte 1 372 commandes. Les deux événements sont inhabituels et les deux sont normaux. Larkfield se prépare au Vendredi fou chaque année, et le temps chaud fait vendre des parasols. Dans le module 5, un bon détecteur ne les signale pas.

Avant d’exécuter la prochaine cellule, le carnet vous demande une prédiction : le flux des commandes a omis une journée. Le graphique montre-t-il une interruption, une chute à zéro ou rien? La cellule énumère tous les jours sans ligne entre la première et la dernière journée :

all_days = pd.date_range(daily.index.min(), daily.index.max(), freq="D")
missing = all_days.difference(daily.index)
print("Days with no orders rows:", [str(d.date()) for d in missing])
Days with no orders rows: ['2025-10-19']

Le graphique ne montre rien. Une journée manquante est un problème de données. Aucun détecteur qui lit des valeurs ne peut la voir, car il n’y a aucune valeur à lire. Un simple décompte des lignes par jour la trouve immédiatement. Mei, responsable des flux, ajoute cette vérification avant l’exécution de tout détecteur. Le même flux a aussi laissé une journée vide dans la table des remboursements, comme le montre votre deuxième tâche.

Chaque module du cours applique ses détecteurs aux mêmes données, les évalue de la même façon et ajoute une ligne au tableau comparatif. Vous pouvez ainsi comparer équitablement une règle du module 2 avec un réseau de neurones du module 6.

Colonne Ce qu’elle indique
alertes par jour le nombre d’alertes que le détecteur envoie chaque jour
précision au budget parmi les 50 alertes que l’équipe de Sofia révise chaque jour, la proportion d’anomalies insérées
rappel la proportion de toutes les anomalies insérées que les alertes révisées trouvent
coût par semaine ($) fraudes manquées (montant + 15 dollars chacune) et fausses alertes (3 dollars chacune) : hypothèses du cours
expliquer une alerte (min) le temps nécessaire à un réviseur pour comprendre une alerte : une hypothèse que vous précisez

compare.split() sépare les paiements en deux parties selon la date, de la même façon pour chaque détecteur :

  • Les mois de référence, de juin à août 2025 : 173 271 paiements. Le détecteur apprend ici ce qui est « normal ».
  • Les mois d’évaluation, de septembre à novembre 2025 : 169 803 paiements sur 91 jours, dont 2 817 insérés, soit environ 31 par jour. Chaque ligne du tableau est évaluée ici.

Les mois d’évaluation sont volontairement plus difficiles. Ils comprennent la nouvelle région, le lancement de l’application et le Vendredi fou : des changements normaux auxquels un détecteur doit résister.

Votre premier détecteur est volontairement simpliste : chaque jour, il signale les 50 montants les plus élevés. Le carnet (notebook) Jupyter vous demande de prédire combien de ces 50 paiements sont frauduleux avant de l’exécuter. La première ligne importe compare.py, le code commun que la cellule de configuration a téléchargé :

import compare
reference, evaluation = compare.split(payments)
table = compare.Table()
table.add(compare.score_payments(evaluation, evaluation.amount, "biggest amounts", "the 50 largest amounts of each day"))
table.show()

score_payments reçoit les paiements et un score par paiement. Ici, le score est le montant, et un score plus élevé signifie « plus inhabituel ». La fonction reçoit aussi un nom et une courte description du réglage. Chaque jour, elle envoie les 50 paiements aux scores les plus élevés à la révision. La sortie :

detector setting alerts per day precision at budget recall cost per week ($) explain one alert (min)
biggest amounts the 50 largest amounts of each day 50.0 0.003 0.005 10264 None

Une précision de 0,003 signifie qu’en moyenne, moins d’une des 50 alertes quotidiennes correspond à une fraude insérée. Le coût est de 10 264 dollars par semaine. Ne rien faire coûte 10 367 dollars par semaine; les montants les plus élevés ne font donc presque rien économiser. Chaque alerte révisée correspondait à un paiement d’une entreprise cliente, et tous ces paiements atteignaient au moins 478,28 dollars. Les entreprises clientes achètent pour des montants plus élevés, sans fraude. La dernière colonne indique None (aucune valeur), car personne n’a précisé le temps nécessaire pour expliquer une alerte. Pour vos propres détecteurs, indiquez-le avec explain_minutes=.

Les « montants les plus élevés » font-ils au moins mieux que le hasard? La section 6 ajoute un détecteur qui choisit 50 paiements par jour au hasard :

rng = np.random.default_rng(0)
table.add(compare.score_payments(evaluation, rng.random(len(evaluation)), "random", "50 payments a day, chosen at random"))
table.show()
detector setting alerts per day precision at budget recall cost per week ($) explain one alert (min)
biggest amounts the 50 largest amounts of each day 50.0 0.003 0.005 10264 None
random 50 payments a day, chosen at random 50.0 0.019 0.031 11161 None

Le choix aléatoire trouve plus de fraudes que les montants les plus élevés : une précision de 0,019. Ce résultat est proche du taux de base des mois d’évaluation (1,66 %). Mais le détecteur aléatoire coûte plus cher que de ne rien faire : 11 161 dollars par semaine. Ses 343,2 fausses alertes par semaine coûtent 3 dollars chacune, et elles permettent de détecter très peu de fraudes. Un détecteur doit justifier le temps consacré à sa révision.

Le graphique place ces lignes à côté du troisième détecteur simpliste de vos tâches, et du plafond : un détecteur qui connaît les réponses.

Précision au budget (50 alertes par jour) de trois détecteurs simplistes pendant les mois d'évaluation : montants les plus élevés, choix aléatoire et montants les plus petits. Parfait représente le plafond, la ligne parfaite du tableau comparatif. Même le plafond est de 0,542, car la plupart des jours comptent moins de 50 paiements insérés.
Description textuelle du graphique

Un diagramme à quatre colonnes, sur un axe allant de 0 à 0,6. Les 50 montants les plus élevés de chaque jour : 0,003. 50 paiements au hasard : 0,019. Les 50 montants les plus petits : 0,192. Un détecteur qui connaît les réponses : 0,542. Le plafond n’est pas 1, car 78 des 91 jours d’évaluation comptent moins de 50 paiements insérés.

Les montants les plus petits font beaucoup mieux que les plus élevés : 0,192. Les tests de cartes utilisent des paiements de 1 à 5 dollars. Les plus petits paiements d’une journée contiennent donc beaucoup de tests de cartes. Pourtant, une règle fondée uniquement sur le montant manque la plupart des fraudes. Le module 2 commence à comparer chaque paiement au montant habituel du client.

Erreur courante

Des scores dans un ordre différent

Symptôme : vous triez les scores, mais pas les paiements, avant de les évaluer. Le carnet le fait volontairement à la section 7 :

wrong = np.sort(evaluation.amount.to_numpy()) # sorted scores: no longer in the order of the payments
row = compare.score_payments(evaluation, wrong, "biggest amounts, wrong order", "scores sorted, payments not")
print(row["precision at budget"], "(the right order gave", table.rows[0]["precision at budget"], ")")
0.011 (the right order gave 0.003 )

La ligne semble normale. Rien ne vous avertit.

Cause : score_payments exige un score par paiement, dans le même ordre que le tableau que vous lui fournissez. Le tri a associé les scores à d’autres paiements. Le détecteur est maintenant un autre détecteur, créé par accident, et sa ligne ne signifie rien.

Solution : calculez le score dans une colonne du même tableau, comme evaluation.amount, ou avec la sortie d’un modèle sur les mêmes lignes. Ne triez jamais l’un sans l’autre. Si vous devez trier, triez le tableau entier, puis calculez les scores.

Conséquence pour le travail en IA : un décalage entre les lignes et les scores donne un nombre crédible pour le mauvais détecteur. Dans une vraie comparaison, il peut faire paraître une méthode faible comme bonne, ou une bonne méthode comme faible. L’équipe choisit alors la mauvaise méthode.

La section 8 du carnet contient trois tâches. Chacune a une cellule de vérification qui indique Check passed (vérification réussie) ou Not yet (pas encore).

  1. Comptez les paiements du Vendredi fou, le 28 novembre 2025. Enregistrez ce nombre dans bf_payments.
  2. Comptez les lignes de refunds_daily.csv où orders est vide. Enregistrez ce nombre dans missing_orders.
  3. Évaluez un troisième détecteur simpliste : chaque jour, les 50 montants les plus petits. Conservez sa ligne dans smallest et ajoutez-la à table.
  4. Exécutez chaque cellule de vérification. Chacune affiche Check passed quand votre réponse est correcte.
Afficher les réponses
bf_payments = int((payments.ts.dt.floor("D") == "2025-11-28").sum())
refunds_daily = pd.read_csv("data/refunds_daily.csv", parse_dates=["date"])
missing_orders = int(refunds_daily.orders.isna().sum())
smallest = compare.score_payments(evaluation, -evaluation.amount, "smallest amounts", "the 50 smallest amounts of each day")
table.add(smallest)
table.show()
detector setting alerts per day precision at budget recall cost per week ($) explain one alert (min)
biggest amounts the 50 largest amounts of each day 50.0 0.003 0.005 10264 None
random 50 payments a day, chosen at random 50.0 0.019 0.031 11161 None
smallest amounts the 50 smallest amounts of each day 50.0 0.192 0.310 9966 None

Les cellules de vérification affichent Check passed: bf_payments is 5216. (vérification réussie : bf_payments vaut 5 216), Check passed: missing_orders is 1. (vérification réussie : missing_orders vaut 1) et Check passed: the precision at budget of the smallest amounts is right. (vérification réussie : la précision au budget des montants les plus petits est correcte).

Le Vendredi fou compte 5 216 paiements, contre environ 1 875 pour une journée moyenne : c’est inhabituel, et normal. Le tableau des remboursements contient un jour sans commandes, le jour où le flux de commandes s’est interrompu. Le signe moins dans -evaluation.amount transforme « plus petit » en « score le plus élevé ». En effet, score_payments révise toujours les scores les plus élevés en premier.

Si quelque chose ne fonctionne plus, supprimez le dossier anomaly-course et exécutez de nouveau le carnet depuis le début.

Vérifiez votre compréhension

Le flux de commandes s'est interrompu le 19 octobre 2025. Pourquoi le graphique des commandes quotidiennes ne le montre-t-il pas, et quelle vérification le détecte?

Afficher la réponse

Ce jour n’a aucune ligne, donc aucune valeur à tracer. La courbe du graphique relie le 18 octobre au 20 octobre, et le manque est invisible. Aucun détecteur qui lit les valeurs ne peut le voir non plus. Une vérification simple le trouve immédiatement : comparez les jours qui ont des lignes à la liste de tous les jours entre le premier et le dernier. Elle affiche Days with no orders rows: ['2025-10-19'] (jours sans lignes de commandes : 19 octobre 2025). Faites ce type de vérification sur les données avant d’appliquer un détecteur.

Vérifiez votre compréhension

Prédisez et expliquez : le détecteur aléatoire a une meilleure précision au budget que les « montants les plus élevés » (0,019 contre 0,003). Mais il coûte plus cher par semaine que de ne rien faire (11 161 contre 10 367 dollars). Comment les deux peuvent-ils être vrais?

Afficher la réponse

Un choix aléatoire trouve des fraudes à peu près au taux de base des mois d’évaluation (1,66 %). Les montants les plus élevés sont tous des paiements d’entreprises clientes, presque tous sans fraude. Le choix aléatoire gagne donc sur la précision. Mais chaque alerte coûte du temps de révision. Le détecteur aléatoire envoie 343,2 fausses alertes par semaine à 3 dollars chacune, et détecte très peu de fraudes. Le temps de révision coûte plus cher que les fraudes évitées. Un détecteur ne vaut la peine d’être utilisé que si ses alertes économisent plus qu’elles ne coûtent.

Vérifiez votre compréhension

Pourquoi chaque détecteur du cours utilise-t-il la même séparation et le même budget? Les mois de référence vont de juin à août, et ceux d'évaluation, de septembre à novembre.

Afficher la réponse

Pour pouvoir comparer les lignes du tableau comparatif. Supposons qu’un détecteur soit évalué sur un mois calme, et un autre sur le mois du lancement de l’application. Ou que l’un reçoive 50 alertes par jour et l’autre, 200. Une différence dans le tableau pourrait alors venir des données ou du budget, plutôt que de la méthode. Avec la même séparation, le même budget et les mêmes coûts, la seule différence entre deux lignes est le détecteur.

Récapitulatif

  • Le cours contient onze tables en quatre groupes : paiements, remboursements, service ticket-api, et commandes et billets de soutien quotidiens.
  • Nous avons inséré 4 971 paiements frauduleux dans 523 épisodes. Nous avons aussi marqué des événements sans fraude qui semblent inhabituels : voyages, commandes en gros, nouvelle région, lancement de l’application, Vendredi fou.
  • Le corrigé est scellé, pas secret : compare.py l’utilise pour l’évaluation. Vous pouvez le déballer, mais vos scores ont alors moins de valeur.
  • Un jour manquant est invisible dans un graphique et pour tout détecteur qui lit les valeurs. Comptez les lignes par jour.
  • Le tableau comparatif évalue chaque détecteur sur les mêmes mois d’évaluation, à 50 alertes par jour, avec les mêmes coûts. Les 50 montants les plus élevés obtiennent 0,003, le choix aléatoire 0,019, les montants les plus petits 0,192, et le plafond est de 0,542.

Vous pouvez maintenant charger les données et évaluer un détecteur équitablement. Mais jusqu’ici, chaque détecteur examinait tous les paiements ensemble, et les montants les plus élevés ne trouvaient presque rien. Ensuite, au module 2, vous mesurez l’écart de chaque paiement par rapport à la normale avec une cote z (z-score). Vous voyez aussi comment un seul paiement énorme trompe la moyenne.

Leçon suivante : Les cotes z, et pourquoi la moyenne se fait tromper