# Exemple sur DONNÉES FICTIVES pour l'article « Données synthétiques : ce qu'elles # valident, ce qu'elles ne valident pas ». # # Aucune donnée réelle. Les clients, leurs caractéristiques et leurs étiquettes de # départ sont tirés au hasard par ce script, avec une graine fixe : chaque exécution # imprime les mêmes chiffres. Bibliothèque standard de Python 3 uniquement. # Exécution : python3 -I donnees-synthetiques-ce-quelles-valident.py import math import random GRAINE = 20261113 N_TRAIN = 7000 N_TEST = 3000 N_AUTRE = 3000 rng = random.Random(GRAINE) VARIABLES = [ "variation_flux", # variation des flux entrants sur 3 mois, en % "produits", # nombre de produits détenus (1 à 6) "jours_connexion", # jours depuis la dernière connexion à l'application "anciennete", # ancienneté de la relation, en années "operations_carte", # opérations par carte par mois "solde_moyen", # solde moyen du compte courant, en euros ] def client_fictif(identifiant): return { "id": identifiant, "variation_flux": max(-90.0, min(60.0, rng.gauss(0.0, 20.0))), "produits": rng.choices([1, 2, 3, 4, 5, 6], weights=[18, 27, 24, 16, 10, 5])[0], "jours_connexion": min(180.0, rng.expovariate(1 / 20.0)), "anciennete": rng.uniform(0.0, 30.0), "operations_carte": max(0.0, rng.gauss(35.0, 15.0)), "solde_moyen": rng.lognormvariate(7.3, 0.9), } def regle_fabrication(c): """Règle qui fabrique les étiquettes synthétiques (trois variables).""" return c["variation_flux"] <= -25 and (c["produits"] <= 2 or c["jours_connexion"] >= 45) def regle_autre(c): """Autre comportement de départ, inconnu au moment de l'entraînement.""" return (c["anciennete"] <= 2 and c["operations_carte"] >= 45) or c["jours_connexion"] >= 90 def etiqueter(clients, regle, bruit=0.01): y = [] for c in clients: v = regle(c) if rng.random() < bruit: v = not v y.append(1 if v else 0) return y # --- Régression logistique écrite à la main (descente de gradient) --- def standardiser(clients, moyennes=None, ecarts=None): if moyennes is None: moyennes, ecarts = {}, {} for v in VARIABLES: xs = [c[v] for c in clients] m = sum(xs) / len(xs) s = math.sqrt(sum((x - m) ** 2 for x in xs) / len(xs)) moyennes[v], ecarts[v] = m, s X = [[(c[v] - moyennes[v]) / ecarts[v] for v in VARIABLES] for c in clients] return X, moyennes, ecarts def sigmoide(z): if z >= 0: return 1 / (1 + math.exp(-z)) e = math.exp(z) return e / (1 + e) def entrainer(X, y, iterations=600, pas=0.5): p = len(X[0]) w = [0.0] * p b = 0.0 n = len(X) for _ in range(iterations): gw = [0.0] * p gb = 0.0 for xi, yi in zip(X, y): err = sigmoide(b + sum(wj * xj for wj, xj in zip(w, xi))) - yi gb += err for j in range(p): gw[j] += err * xi[j] b -= pas * gb / n w = [wj - pas * gj / n for wj, gj in zip(w, gw)] return w, b def scorer(X, w, b): return [sigmoide(b + sum(wj * xj for wj, xj in zip(w, xi))) for xi in X] def auc(scores, y): """AUC par tri : statistique de Mann-Whitney, rangs moyens en cas d'égalité.""" ordre = sorted(range(len(scores)), key=lambda i: scores[i]) rangs = [0.0] * len(scores) i = 0 while i < len(ordre): j = i while j + 1 < len(ordre) and scores[ordre[j + 1]] == scores[ordre[i]]: j += 1 r = (i + j) / 2 + 1 for k in range(i, j + 1): rangs[ordre[k]] = r i = j + 1 n1 = sum(y) n0 = len(y) - n1 somme = sum(r for r, yi in zip(rangs, y) if yi == 1) return (somme - n1 * (n1 + 1) / 2) / (n1 * n0) def taux_premier_decile(scores, y): ordre = sorted(range(len(scores)), key=lambda i: -scores[i]) k = len(scores) // 10 return sum(y[i] for i in ordre[:k]) / k, k def fr(x, d=1): s = f"{x:,.{d}f}".replace(",", " ").replace(".", ",") return s.replace(" ", " ") # --- 1. Ce que les données synthétiques valident : le contrôle du contrat de données --- clients = [client_fictif(f"C{i:05d}") for i in range(N_TRAIN + N_TEST)] lot = [dict(c) for c in clients] anomalies = {"doublon": 0, "manquant": 0, "negatif": 0} positions = rng.sample(range(len(lot)), 150) for n, k in enumerate(positions): if n < 50: lot[k]["id"] = lot[(k + 1) % len(lot)]["id"] anomalies["doublon"] += 1 elif n < 100: lot[k]["produits"] = None anomalies["manquant"] += 1 else: lot[k]["jours_connexion"] = -rng.randint(1, 30) anomalies["negatif"] += 1 def controler(lignes): vus = set() signalees = set() for i, c in enumerate(lignes): if c["id"] in vus: signalees.add(i) vus.add(c["id"]) if c["produits"] is None or c["jours_connexion"] < 0: signalees.add(i) return signalees def controler_v2(lignes): """Version corrigée : signale toutes les lignes qui partagent un identifiant.""" comptes = {} for c in lignes: comptes[c["id"]] = comptes.get(c["id"], 0) + 1 return {i for i, c in enumerate(lignes) if comptes[c["id"]] > 1 or c["produits"] is None or c["jours_connexion"] < 0} sig_propre = controler(clients) sig_lot = controler(lot) attendues = set(positions) partenaires = {(k + 1) % len(lot) for k in positions[:50]} - attendues sig_v2 = controler_v2(lot) print("1. Contrôle du contrat de données") print(f" lignes : {fr(len(lot), 0)} ; anomalies injectées : {len(positions)} " f"({anomalies['doublon']} identifiants en double, {anomalies['manquant']} valeurs manquantes, " f"{anomalies['negatif']} durées négatives)") print(f" lignes signalées sur le lot propre : {len(sig_propre)}") print(f" anomalies injectées repérées : {len(attendues & sig_lot)} sur {len(attendues)} ; " f"lignes saines signalées à tort : {len(sig_lot - attendues)}") print(f" dont lignes signalées qui sont l'autre moitié d'une paire de doublons : " f"{len((sig_lot - attendues) & partenaires)}") print(f" version corrigée : anomalies repérées {len(attendues & sig_v2)} sur {len(attendues)} ; " f"autres lignes signalées : {len(sig_v2 - attendues)}, toutes partenaires d'un doublon : " f"{(sig_v2 - attendues) <= partenaires} ; lot propre : {len(controler_v2(clients))} ligne signalée") # --- 2. Ce qu'elles ne valident pas : la précision sur un autre comportement --- train, test = clients[:N_TRAIN], clients[N_TRAIN:] y_train = etiqueter(train, regle_fabrication) y_test = etiqueter(test, regle_fabrication) X_train, moy, ec = standardiser(train) X_test, _, _ = standardiser(test, moy, ec) w, b = entrainer(X_train, y_train) s_test = scorer(X_test, w, b) auc_test = auc(s_test, y_test) d1_test, k_test = taux_premier_decile(s_test, y_test) taux_test = sum(y_test) / len(y_test) autres = [client_fictif(f"D{i:05d}") for i in range(N_AUTRE)] y_autres = etiqueter(autres, regle_autre) X_autres, _, _ = standardiser(autres, moy, ec) s_autres = scorer(X_autres, w, b) auc_autres = auc(s_autres, y_autres) d1_autres, k_autres = taux_premier_decile(s_autres, y_autres) taux_autres = sum(y_autres) / len(y_autres) print() print("2. Modèle de départ entraîné sur les étiquettes de la règle de fabrication") print(f" apprentissage : {fr(N_TRAIN, 0)} clients ; taux de départ : {fr(100 * sum(y_train) / len(y_train))} %") print(" coefficients (variables standardisées) :") for v, wj in zip(VARIABLES, w): print(f" {v:<17} {fr(wj, 2)}") print(f" constante {fr(b, 2)}") print(f" test, même règle ({fr(N_TEST, 0)} clients) : taux de départ {fr(100 * taux_test)} % ; " f"AUC {fr(auc_test, 3)} ; départs parmi les {k_test} clients les mieux classés : {fr(100 * d1_test)} %") print(f" autre comportement ({fr(N_AUTRE, 0)} clients) : taux de départ {fr(100 * taux_autres)} % ; " f"AUC {fr(auc_autres, 3)} ; départs parmi les {k_autres} clients les mieux classés : {fr(100 * d1_autres)} %") # Le même modèle, réentraîné sur l'autre comportement : pour mémoire, ce que des # étiquettes réelles auraient permis de voir. y_autres_train = etiqueter(train, regle_autre) w2, b2 = entrainer(X_train, y_autres_train) auc_reent = auc(scorer(X_autres, w2, b2), y_autres) print(f" même famille de modèle, réentraînée sur l'autre comportement : AUC {fr(auc_reent, 3)}")