Le carnet
de bordThe ship's
logbook

Dans un terminal dédié — il reste ouvert pendant tout le lab. Alternative minimale : mlflow ui (même interface, lit le dossier local ./mlruns). In a dedicated terminal — it stays open for the whole lab. Minimal alternative: mlflow ui (same interface, reads the local ./mlruns folder).

cd fraud-detection
source .venv/bin/activate
pip install mlflow matplotlib

mlflow server --host 127.0.0.1 --port 5000

Remplacez src/train/train.py par cette version : les mêmes choix qu'au bloc 2 (split stratifié, scaler dans un Pipeline — jamais le classifieur seul —, class_weight, coût en euros), plus le carnet de bord : params, métriques, artefact, modèle. Replace src/train/train.py with this version: the same choices as block 2 (stratified split, scaler inside a Pipeline — never the bare classifier —, class_weight, cost in euros), plus the logbook: params, metrics, artifact, model.

import argparse

import joblib
import matplotlib
matplotlib.use("Agg")
import matplotlib.pyplot as plt
import mlflow
import mlflow.sklearn
import pandas as pd
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import average_precision_score, precision_recall_curve
from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler


def main(c, class_weight, threshold):
    df = pd.read_csv("data/creditcard.csv")
    X = df.drop(columns=["Class"])
    y = df["Class"]
    X_tr, X_te, y_tr, y_te = train_test_split(
        X, y, test_size=0.2, stratify=y, random_state=42)

    cw = None if class_weight == "none" else class_weight
    model = Pipeline([
        ("scaler", StandardScaler()),
        ("clf", LogisticRegression(C=c, class_weight=cw, max_iter=1000)),
    ])

    mlflow.set_tracking_uri("http://127.0.0.1:5000")
    mlflow.set_experiment("fraud-detector")
    with mlflow.start_run():
        mlflow.log_params({"C": c, "class_weight": class_weight,
                           "threshold": threshold,
                           "features": "time_v1_v28_amount"})

        model.fit(X_tr, y_tr)
        proba = model.predict_proba(X_te)[:, 1]
        pred = (proba >= threshold).astype(int)

        pr_auc = average_precision_score(y_te, proba)
        missed = (y_te == 1) & (pred == 0)
        false_alert = (y_te == 0) & (pred == 1)
        cost = X_te.loc[missed, "Amount"].sum() + 15 * false_alert.sum()
        mlflow.log_metrics({"pr_auc": pr_auc, "cost_eur": float(cost)})

        prec, rec, _ = precision_recall_curve(y_te, proba)
        plt.plot(rec, prec)
        plt.xlabel("recall")
        plt.ylabel("precision")
        plt.savefig("pr_curve.png")
        mlflow.log_artifact("pr_curve.png")

        mlflow.sklearn.log_model(model, "model")
        joblib.dump(model, "models/model.joblib")
        print(f"pr_auc={pr_auc:.4f}  cost_eur={cost:.0f}")


if __name__ == "__main__":
    p = argparse.ArgumentParser()
    p.add_argument("--c", type=float, default=1.0)
    p.add_argument("--class-weight", default="balanced")
    p.add_argument("--threshold", type=float, default=0.5)
    a = p.parse_args()
    main(a.c, a.class_weight, a.threshold)

Un changement par run — la boucle scientifique du bloc 2, mais chaque page s'écrit toute seule. Dans un second terminal (venv activé) : One change per run — block 2's scientific loop, but every page now writes itself. In a second terminal (venv activated):

mkdir -p models
python src/train/train.py --c 1.0 --class-weight balanced --threshold 0.5
python src/train/train.py --c 0.1 --class-weight balanced --threshold 0.3
python src/train/train.py --c 1.0 --class-weight none --threshold 0.5

Segments fixés à l'avance, les mêmes pour tous les modèles : gros montants et nuit. Ajoutez ce bloc dans train.py, à l'intérieur du with mlflow.start_run():, après le calcul de proba — puis relancez un run. Segments fixed up front, the same for every model: large amounts and night. Add this block to train.py, inside the with mlflow.start_run():, after proba is computed — then launch one more run.

        y_true = y_te.to_numpy()
        segments = {
            "large_amounts": (X_te["Amount"] > 1000).to_numpy(),
            "night": ((X_te["Time"] % 86400) < 6 * 3600).to_numpy(),
        }
        for name, mask in segments.items():
            if y_true[mask].sum() > 0:
                seg_auc = average_precision_score(y_true[mask], proba[mask])
                mlflow.log_metric(f"pr_auc_{name}", seg_auc)
                print(f"pr_auc_{name}={seg_auc:.4f}  ({int(mask.sum())} tx)")

Deux voies. Voie UI : ouvrez votre meilleur run → artefact model → bouton Register model → nom fraud-detector. Voie code : copiez le Run ID depuis l'UI, puis exécutez ceci (une fois pour un run moyen → version 1, une fois pour votre meilleur run → version 2) : Two routes. UI route: open your best run → model artifact → Register model button → name fraud-detector. Code route: copy the Run ID from the UI, then run this (once for an average run → version 1, once for your best run → version 2):

import mlflow

mlflow.set_tracking_uri("http://127.0.0.1:5000")
result = mlflow.register_model("runs:/<RUN_ID>/model", "fraud-detector")
print(f"registered: version {result.version}")

Dans MLflow récent, les alias remplacent les stages (Staging/Production) : un alias est un pointeur nommé, déplaçable en une ligne. Créez scripts/promote.py puis exécutez-le : In recent MLflow, aliases replace stages (Staging/Production): an alias is a named pointer you can move in one line. Create scripts/promote.py then run it:

from mlflow import MlflowClient

client = MlflowClient(tracking_uri="http://127.0.0.1:5000")
client.set_registered_model_alias("fraud-detector", "production", version=2)
print("alias @production -> version 2")

mkdir -p scripts
python scripts/promote.py

Remplacez le haut de src/serve/app.py (imports, lifespan, /health) par ceci — vos endpoints /predict et schémas Pydantic du bloc 3 restent inchangés dessous, ils lisent state["model"] : Replace the top of src/serve/app.py (imports, lifespan, /health) with this — your block 3 /predict endpoints and Pydantic schemas stay unchanged below, they read state["model"]:

import os
from contextlib import asynccontextmanager

import joblib
import mlflow
import mlflow.sklearn
from fastapi import FastAPI

state = {}


@asynccontextmanager
async def lifespan(app: FastAPI):
    mlflow.set_tracking_uri(
        os.getenv("MLFLOW_TRACKING_URI", "http://127.0.0.1:5000"))
    try:
        state["model"] = mlflow.sklearn.load_model(
            "models:/fraud-detector@production")
        state["model_source"] = "registry"
    except Exception as exc:
        print(f"registry unavailable ({exc}), falling back to joblib")
        state["model"] = joblib.load("models/model.joblib")
        state["model_source"] = "joblib_fallback"
    yield
    state.clear()


app = FastAPI(lifespan=lifespan)


@app.get("/health")
def health():
    return {"status": "ok", "model_source": state["model_source"]}

Serveur MLflow toujours ouvert dans son terminal. Dans le second terminal, relancez uvicorn puis interrogez /health — ensuite, déplacez l'alias vers la version 1 (scripts/promote.py avec version=1), relancez : le modèle servi change sans toucher au code. MLflow server still open in its terminal. In the second terminal, restart uvicorn then query /health — next, move the alias to version 1 (scripts/promote.py with version=1) and restart: the served model changes without touching the code.

export MLFLOW_TRACKING_URI=http://127.0.0.1:5000
uvicorn src.serve.app:app --port 8000

curl http://127.0.0.1:8000/health