1. Cadrage métier       définir la question, la métrique, l'usage du résultat    ~10 %
2. Collecte / accès     trouver, extraire, joindre les données                   ~20 %
3. Exploration          comprendre les données, détecter les anomalies           ~15 %
4. Préparation          nettoyage, features, encodages                           ~25 %
5. Modélisation         baseline, puis itérations                                ~10 %
6. Évaluation           protocole, métriques, analyse d'erreurs                  ~10 %
7. Déploiement / suivi  mise en production, monitoring, ré-entraînement          ~10 %

from sklearn.dummy import DummyRegressor, DummyClassifier

# régression : prédire toujours la moyenne (ou la médiane)
base = DummyRegressor(strategy="median").fit(X_tr, y_tr)

# classification : prédire toujours la classe majoritaire
base = DummyClassifier(strategy="most_frequent").fit(X_tr, y_tr)

# série temporelle : la valeur de la veille, ou celle de l'an dernier (module 17)
pred_naive = y[:-1]

# et surtout : la RÈGLE MÉTIER existante, si elle existe
pred_regle = np.where(df["anciennete"] < 3, 1, 0)

Structure      dimensions, types, mémoire, granularité (une ligne = quoi ?)
Cible          distribution, taux de positifs, extrêmes, évolution dans le temps
Manquants      taux par colonne, et STRUCTURE des manquants (section 5)
Doublons       lignes identiques ET doublons sur la clé métier
Cardinalité    colonnes constantes (inutiles), identifiants déguisés (dangereux)
Distributions  asymétrie, multimodalité, valeurs impossibles (âge = 200, prix < 0)
Temps          couverture, trous, saisonnalité, ruptures de collecte
Relations      corrélations entre variables, lien de chaque variable avec la cible
Groupes        déséquilibres entre segments, sous-populations sous-représentées

import polars as pl

df = pl.read_parquet("data/clients.parquet")

print(df.shape, df.estimated_size("mb"))
print(df.describe())                                     # stats par colonne
print(df.null_count())                                   # manquants par colonne
print(df.select(pl.all().n_unique()))                    # cardinalités
print(df.filter(pl.struct(df.columns).is_duplicated()))  # doublons exacts

# valeurs impossibles : toujours confronter aux bornes MÉTIER
print(df.filter((pl.col("age") < 0) | (pl.col("age") > 120)))

# la cible dans le temps : LE graphique qui révèle les ruptures de collecte
print(df.group_by_dynamic("date", every="1w").agg(
          taux=pl.col("cible").mean(), n=pl.len()))

# lien de chaque variable numérique avec la cible
print(df.select(pl.corr(pl.col(c), pl.col("cible")).alias(c)
                for c in colonnes_numeriques))

import matplotlib.pyplot as plt, seaborn as sns

fig, ax = plt.subplots(2, 2, figsize=(12, 8))

sns.histplot(df["prix"], log_scale=True, ax=ax[0, 0])          # 1. la cible
ax[0, 0].set_title("distribution de la cible (échelle log)")

df.set_index("date")["cible"].resample("W").mean().plot(ax=ax[0, 1])   # 2. le temps
ax[0, 1].set_title("taux de positifs par semaine")

sns.heatmap(df[num].corr(), cmap="RdBu_r", center=0, ax=ax[1, 0])      # 3. corrélations
ax[1, 0].set_title("corrélations entre variables")

sns.boxplot(data=df, x="segment", y="prix", ax=ax[1, 1])               # 4. par groupe
ax[1, 1].set_yscale("log")
plt.tight_layout()

# le taux de manquants dépend-il des autres variables ? (indice de MAR)
df["revenu_manquant"] = df["revenu"].isna()
print(df.groupby("revenu_manquant")[["age", "anciennete", "cible"]].mean())
# si les moyennes diffèrent nettement → le manque est INFORMATIF

# les manquants sont-ils groupés ? (plusieurs colonnes absentes ensemble)
import missingno as msno
msno.matrix(df); msno.heatmap(df)     # visualise la co-occurrence des manquants

Supprimer les lignes      acceptable si < 5 % et MCAR. Sinon on biaise l'échantillon.
Supprimer la colonne      si > 60-70 % manquants ET aucun signal dans le fait de manquer.
Moyenne / médiane         rapide ; réduit artificiellement la variance et écrase
                          les corrélations. Acceptable comme baseline.
KNN / itératif (MICE)     impute à partir des autres colonnes ; coûteux, bien meilleur.
Valeur sentinelle         -1, "inconnu" : parfait pour les modèles à base d'arbres,
                          qui peuvent isoler cette modalité.
Ne rien faire             HistGradientBoosting, XGBoost et LightGBM gèrent nativement
                          les NaN et APPRENNENT la meilleure direction pour eux.
Indicateur de manque      ajouter une colonne booléenne : le FAIT de manquer est
                          souvent informatif (un client qui ne renseigne pas
                          son revenu n'est pas un client au hasard).

from sklearn.experimental import enable_iterative_imputer   # noqa: F401
from sklearn.impute import IterativeImputer, SimpleImputer

# imputation multivariée : chaque colonne est prédite à partir des autres, en boucle
imp = IterativeImputer(max_iter=10, random_state=0)

# conserver l'information "cette valeur manquait" : ajoute une colonne booléenne
imp = SimpleImputer(strategy="median", add_indicator=True)

One-hot          une colonne par modalité. Défaut sûr. Explose si cardinalité élevée.
Ordinal          un entier par modalité. Uniquement si un ORDRE existe réellement
                 (S < M < L), ou pour des arbres, qui savent découper n'importe où.
Target encoding  remplace la modalité par la moyenne de la cible. Très puissant sur
                 forte cardinalité (code postal, produit) — et très exposé à la fuite.
Hashing          projette dans un espace de taille fixe. Utile en flux, perd la lisibilité.
Embeddings       représentation dense apprise. Pour les réseaux (module 16).

import numpy as np, polars as pl

df = df.with_columns(
    # 1. transformations : log pour les queues lourdes (prix, revenus, durées)
    log_prix=pl.col("prix").log1p(),           # log1p gère la valeur 0

    # 2. RATIOS et interactions : souvent l'apport décisif. Les arbres approchent
    #    très mal un ratio (il leur faut des dizaines de coupes), il faut le fournir.
    prix_m2=pl.col("prix") / pl.col("surface"),
    revenu_par_personne=pl.col("revenu") / pl.col("taille_foyer"),
    intensite=pl.col("n_connexions") / pl.col("anciennete_jours"),

    # 3. variables de calendrier
    jour_semaine=pl.col("date").dt.weekday(),
    mois=pl.col("date").dt.month(),
    est_weekend=pl.col("date").dt.weekday() >= 6,

    # 4. variables CYCLIQUES : pour que 23 h soit proche de 0 h
    heure_sin=(2 * np.pi * pl.col("date").dt.hour() / 24).sin(),
    heure_cos=(2 * np.pi * pl.col("date").dt.hour() / 24).cos(),

    # 5. agrégats à fenêtre STRICTEMENT passée (le shift(1) est essentiel)
    depense_moy_30j=pl.col("montant").shift(1).rolling_mean(30).over("client_id"),
    n_achats_7j=pl.col("montant").shift(1).rolling_count(7).over("client_id"),
)

from sklearn.metrics import precision_recall_curve

# 1 et 2 : métrique adaptée et pondération
modele = LGBMClassifier(scale_pos_weight=(y_tr == 0).sum() / (y_tr == 1).sum())
modele.fit(X_tr, y_tr, eval_metric="average_precision")

# 3 : choisir le seuil sur la courbe précision-rappel, pas à 0,5
p = modele.predict_proba(X_val)[:, 1]
prec, rap, seuils = precision_recall_curve(y_val, p)
# par exemple : le seuil qui garantit au moins 80 % de précision
i = np.argmax(prec[:-1] >= 0.80)
print(f"seuil = {seuils[i]:.3f} → précision {prec[i]:.1%}, rappel {rap[i]:.1%}")

KFold (K=5)                     TimeSeriesSplit
pli 1  [test][─── train ───]    pli 1  [train][test]·············
pli 2  [train][test][ train ]   pli 2  [── train ──][test]·······
pli 3  [── train ─][test][──]   pli 3  [──── train ───][test]····
pli 4  [─── train ──][test][]   pli 4  [────── train ────][test]·
pli 5  [──── train ────][test]         ↑ on n'entraîne JAMAIS sur le futur

GroupKFold (groupe = client)
client A ██  B ██  C ██  D ██  E ██     un client entier va d'un seul côté :
pli 1    test    train train train      pas de client des deux côtés du découpage

KFold                  données i.i.d., régression                 K = 5 ou 10
StratifiedKFold        classification : conserve les proportions  le défaut en classif
GroupKFold             plusieurs lignes par entité (patient,      un groupe = un seul pli
                       client, bien immobilier)
StratifiedGroupKFold   les deux contraintes à la fois
TimeSeriesSplit        séries temporelles : entraîner sur le      jamais de mélange
                       passé, tester sur le futur
LeaveOneOut            très peu de données                        coûteux, variance élevée
Nested CV              on optimise DES hyperparamètres ET on veut boucle interne = réglage
                       une estimation non biaisée                 boucle externe = évaluation

from sklearn.model_selection import GroupKFold, cross_validate

# données transactionnelles : plusieurs lignes par client → GroupKFold
res = cross_validate(pipeline, X, y, groups=df["client_id"],
                     cv=GroupKFold(n_splits=5),
                     scoring=["roc_auc", "average_precision"],
                     return_train_score=True, n_jobs=-1)

# l'écart train/validation mesure directement le surapprentissage
print(f"train {res['train_roc_auc'].mean():.3f} | "
      f"val {res['test_roc_auc'].mean():.3f} ± {res['test_roc_auc'].std():.3f}")

Prétraitement global     scaler, imputeur, PCA, sélection de variables ajustés sur TOUT
                         le jeu avant le découpage.    → tout mettre dans un Pipeline

Fuite temporelle         une variable utilise de l'information postérieure à la date
                         de prédiction : moyenne calculée sur toute la période,
                         statut final du dossier.      → figer une date de référence

Duplication              la même observation (ou quasi) des deux côtés du découpage :
                         doublons, utilisateur présent plusieurs fois.  → GroupKFold

Cible déguisée           une colonne qui n'existe QUE parce que l'événement a eu lieu :
                         "date de résiliation", "montant remboursé", "motif de panne".

Target encoding naïf     moyenne de cible calculée en incluant la ligne courante.
                         → encodage en validation croisée interne

Fuite par le seuil       choisir le seuil de décision sur le jeu de test.

Sélection répétée        essayer 200 modèles et garder le meilleur score de test :
                         le test devient un jeu d'entraînement déguisé.