Un guide pratique pour les développeurs d'IA à qui l'on a demandé « comment savez-vous que cela fonctionne ? » à propos d'un modèle ou d'une fonctionnalité LLM, et qui ne peuvent pas répondre par une preuve. Vous allez construire, en environ 400 lignes de Python, les éléments probants qui la remplacent : un banc d'évaluation avec des métriques par segment et un contrat de réussite ou d'échec, des tests basés sur les propriétés et des tests métamorphiques, la calibration et la prédiction conforme, des contrats de sortie et une évaluation de non-régression pour une étape LLM, des contrôles de dérive, une barrière en CI et la vérification formelle exacte d'un petit réseau de neurones. Chaque bloc ci-dessous a été exécuté, et la sortie affichée est réelle.
Cette note technique accompagne notre article de blog La correction prouvable échoue en IA : quels éléments probants construire à la place, qui traite des aspects métier et réglementaires. Les faits sont à jour au 16 novembre 2026.
À qui s'adresse ce guide, ce que vous allez construire, prérequis
À qui s'adresse ce guide : ingénieurs ML et IA, data scientists qui mettent des modèles en production, et ingénieurs plateforme responsables des pipelines qui les entourent. Vous connaissez Python et pytest ; aucune formation en méthodes formelles n'est nécessaire.
Ce que vous allez construire : un petit projet, evidence/, autour d'un classificateur de remboursement de prêts entraîné sur des données synthétiques dont la vérité terrain est connue, ainsi qu'une étape d'extraction de factures qui tient lieu de LLM. Chaque fichier produit un type d'élément probant ; gate.sh les exécute tous et fait échouer le build si l'un d'eux échoue.
Prérequis : Python 3.10 ou ultérieur (nous avons utilisé la 3.12), environ 300 Mo d'espace disque pour les bibliothèques, n'importe quel processeur d'ordinateur portable. Ni GPU ni clé d'API ne sont nécessaires. Nous avons testé avec NumPy 2.5.5, SciPy 1.18.1, scikit-learn 1.9.1, Hypothesis 6.170.15, Pydantic 2.14.3, MAPIE 1.6.0 et pytest 9.2.0.
Étape 0 : installation
mkdir evidence && cd evidence
python3 -m venv .venv && . .venv/bin/activate
pip install numpy scipy scikit-learn hypothesis pydantic pytest mapie
export OMP_NUM_THREADS=1 # see "Pitfalls": per-row predictions get ~100x slower without it on a busy machine
Étape 1 : des données dont la vérité terrain est connue
Les données réelles conviennent mieux aux décisions réelles, mais pour apprendre les techniques, il vous faut un jeu de données dont vous connaissez la bonne réponse. Ici, le remboursement dépend du revenu (à la hausse), du taux d'endettement (à la baisse), de l'ancienneté dans l'emploi (à la hausse) et de la région, la plus petite région étant légèrement défavorisée. Chaque test ci-dessous a donc un résultat correct.
"""Synthetic loan data with a known ground truth, so every test has a right answer."""
import numpy as np
FEATURES = ["income_k", "debt_ratio", "years_employed", "region"]
REGIONS = ["north", "south", "east", "west"]
def make_loans(n: int, seed: int = 0, income_shift: float = 0.0):
rng = np.random.default_rng(seed)
income = rng.lognormal(mean=10.4 + income_shift, sigma=0.5, size=n) # GBP a year
debt_ratio = rng.beta(2, 5, size=n)
years = rng.integers(0, 30, size=n)
region = rng.choice(4, size=n, p=[0.4, 0.3, 0.2, 0.1])
logit = (1.5 * (np.log(income) - 10.4) - 4.0 * (debt_ratio - 0.3)
+ 0.05 * (years - 8) - 0.3 * (region == 3))
y = (rng.random(n) < 1 / (1 + np.exp(-logit))).astype(int) # 1 = repaid
X = np.column_stack([income / 1000, debt_ratio, years, region]).astype(float)
return X, y
Étape 2 : entraîner le modèle, avec deux règles intégrées
HistGradientBoostingClassifier de scikit-learn accepte monotonic_cst, qui oblige le score à évoluer dans un seul sens lorsqu'une variable augmente [1]. Nous entraînons un modèle avec ces contraintes et un autre sans, afin de voir ce que les tests détectent.
"""Train the model under test. monotonic_cst encodes two business rules by construction."""
import joblib
from sklearn.ensemble import HistGradientBoostingClassifier
from data import make_loans
def train(constrained: bool = True, seed: int = 0):
X, y = make_loans(20_000, seed=seed)
clf = HistGradientBoostingClassifier(
max_iter=300, learning_rate=0.05, random_state=seed,
categorical_features=[3],
# +1: more income never lowers the score; -1: more debt never raises it
monotonic_cst=[1, -1, 0, 0] if constrained else None,
)
return clf.fit(X, y)
if __name__ == "__main__":
joblib.dump(train(constrained=True), "model.joblib")
joblib.dump(train(constrained=False), "model_unconstrained.joblib")
print("saved model.joblib and model_unconstrained.joblib")
Étape 3 : un banc d'évaluation avec un contrat
Le contrat est ce qui se rapproche le plus d'une spécification : des seuils convenus avec le métier avant l'entraînement. Le banc d'essai rapporte la ROC AUC sur les données de test (la capacité du score à classer les bons payeurs au-dessus des défaillants), le score de Brier et l'erreur de calibration attendue (ECE, l'écart moyen entre la probabilité prédite et la fréquence observée), puis les mêmes valeurs par région avec des intervalles de confiance bootstrap à 95 %. Il applique la barrière sur la borne inférieure de l'intervalle de chaque segment, afin qu'un petit segment ne puisse pas réussir par chance, et il se termine avec un code non nul en cas d'échec, ce qui le rend utilisable en CI.
"""Held-out and per-slice evaluation with bootstrap confidence intervals and a pass/fail contract."""
import json
import sys
import joblib
import numpy as np
from sklearn.metrics import roc_auc_score, brier_score_loss
from data import make_loans, REGIONS
CONTRACT = { # agreed with the business before training
"auc_min": 0.70, # overall held-out ROC AUC
"slice_auc_lower_ci_min": 0.62, # worst slice, lower end of the 95% CI
"ece_max": 0.03, # expected calibration error
"min_slice_n": 300, # below this a slice is reported, not gated
}
def ece(y, p, bins=10):
"""Expected calibration error: weighted gap between confidence and frequency."""
edges = np.linspace(0, 1, bins + 1)
idx = np.clip(np.digitize(p, edges) - 1, 0, bins - 1)
return sum(abs(p[idx == b].mean() - y[idx == b].mean()) * (idx == b).mean()
for b in range(bins) if (idx == b).any())
def bootstrap_auc(y, p, n_boot=1000, seed=0):
rng = np.random.default_rng(seed)
stats = []
for _ in range(n_boot):
i = rng.integers(0, len(y), len(y))
if y[i].min() != y[i].max():
stats.append(roc_auc_score(y[i], p[i]))
return np.percentile(stats, [2.5, 97.5])
def evaluate(model_path="model.joblib", seed=1):
model = joblib.load(model_path)
X, y = make_loans(10_000, seed=seed) # held-out: a seed never used in training
p = model.predict_proba(X)[:, 1]
report = {"n": len(y), "auc": roc_auc_score(y, p),
"brier": brier_score_loss(y, p), "ece": ece(y, p), "slices": {}}
for code, name in enumerate(REGIONS):
m = X[:, 3] == code
lo, hi = bootstrap_auc(y[m], p[m])
report["slices"][name] = {"n": int(m.sum()), "auc": roc_auc_score(y[m], p[m]),
"auc_ci": [lo, hi]}
failures = []
if report["auc"] < CONTRACT["auc_min"]:
failures.append(f"auc {report['auc']:.3f} < {CONTRACT['auc_min']}")
if report["ece"] > CONTRACT["ece_max"]:
failures.append(f"ece {report['ece']:.3f} > {CONTRACT['ece_max']}")
for name, s in report["slices"].items():
if s["n"] >= CONTRACT["min_slice_n"] and s["auc_ci"][0] < CONTRACT["slice_auc_lower_ci_min"]:
failures.append(f"slice {name}: AUC lower CI {s['auc_ci'][0]:.3f}")
report["failures"] = failures
return report
if __name__ == "__main__":
r = evaluate(*sys.argv[1:2])
print(f"held-out n={r['n']} AUC={r['auc']:.3f} Brier={r['brier']:.3f} ECE={r['ece']:.3f}")
for name, s in r["slices"].items():
print(f" {name:<6} n={s['n']:>5} AUC={s['auc']:.3f} 95% CI [{s['auc_ci'][0]:.3f}, {s['auc_ci'][1]:.3f}]")
json.dump(r, open("eval_report.json", "w"), indent=2, default=float)
print("PASS" if not r["failures"] else "FAIL: " + "; ".join(r["failures"]))
sys.exit(1 if r["failures"] else 0)
$ python eval_harness.py
held-out n=10000 AUC=0.747 Brier=0.200 ECE=0.014
north n= 3989 AUC=0.749 95% CI [0.735, 0.764]
south n= 2920 AUC=0.759 95% CI [0.740, 0.778]
east n= 2065 AUC=0.735 95% CI [0.714, 0.756]
west n= 1026 AUC=0.723 95% CI [0.694, 0.753]
PASS
$ python eval_harness.py model_unconstrained.joblib
held-out n=10000 AUC=0.747 Brier=0.200 ECE=0.012
...
PASS
Observez les largeurs : le segment ouest, avec 1 026 cas, a un intervalle presque deux fois plus large que celui du nord. Les deux modèles réussissent. Sur la base de ces seuls chiffres, vous ne pourriez pas les départager : c'est la sous-spécification en miniature, un même pipeline, de nombreux modèles avec le même score sur les données de test [2].
Étape 4 : tests basés sur les propriétés et tests métamorphiques
Un test basé sur les propriétés énonce une règle et laisse une bibliothèque générer les entrées. Hypothesis génère des centaines de cas et, lorsque l'un d'eux échoue, le réduit à l'exemple d'échec le plus simple [3]. Un test métamorphique est une propriété qui relie deux exécutions : vous ne connaissez pas le bon score pour un demandeur, mais vous savez qu'une augmentation de son revenu ne doit pas le faire baisser. Cette idée vient du test logiciel, où elle a été développée pour les programmes dépourvus d'oracle de test fiable [4] ; CheckList a appliqué la même idée aux modèles de NLP sous forme de tests d'invariance et de tests directionnels [5].
"""Property-based and metamorphic tests: rules that must hold for every input, not just the test set."""
import os
import joblib
import numpy as np
from hypothesis import given, settings, strategies as st
MODEL = joblib.load(os.environ.get("MODEL", "model.joblib"))
applicant = st.tuples(
st.floats(5, 500), # income_k
st.floats(0, 1), # debt_ratio
st.integers(0, 45), # years_employed
st.integers(0, 3), # region code
)
def proba(rows):
return MODEL.predict_proba(np.asarray(rows, dtype=float))[:, 1]
@settings(max_examples=300, deadline=None)
@given(applicant)
def test_output_is_a_probability(a):
p = proba([a])
assert p.shape == (1,) and 0.0 <= p[0] <= 1.0
@settings(max_examples=300, deadline=None)
@given(applicant, st.floats(0.1, 200))
def test_more_income_never_lowers_score(a, extra): # metamorphic relation
richer = (a[0] + extra, *a[1:])
assert proba([richer])[0] >= proba([a])[0] - 1e-9
@settings(max_examples=300, deadline=None)
@given(applicant, st.floats(0.01, 0.5))
def test_more_debt_never_raises_score(a, extra):
worse = (a[0], min(1.0, a[1] + extra), *a[2:])
assert proba([worse])[0] <= proba([a])[0] + 1e-9
@settings(max_examples=100, deadline=None)
@given(st.lists(applicant, min_size=2, max_size=20), st.randoms())
def test_batch_order_does_not_change_answers(rows, rnd): # invariance
perm = list(range(len(rows)))
rnd.shuffle(perm)
p = proba(rows)
assert np.allclose(proba([rows[i] for i in perm]), p[perm])
$ python -m pytest -q test_properties.py
.... [100%]
4 passed in 4.51s
$ MODEL=model_unconstrained.joblib python -m pytest -q test_properties.py
.FF. [100%]
E assert np.float64(0.8262130572178492) >= (np.float64(0.8346077610546677) - 1e-09)
E Failing test case: test_more_income_never_lowers_score(
E a=(33.0, 0.0, 7, 0),
E extra=1.0,
E )
...
FAILED test_properties.py::test_more_income_never_lowers_score - assert np.fl...
FAILED test_properties.py::test_more_debt_never_raises_score - assert np.floa...
2 failed, 2 passed in 6.91s
Le modèle sans contraintes, avec la même AUC, attribue un score de 0,835 à un demandeur gagnant 33 000 £ et de 0,826 au même demandeur gagnant 34 000 £. Hypothesis l'a trouvé et l'a réduit à des nombres ronds. Votre exemple d'échec peut être différent, car la génération est aléatoire ; Hypothesis enregistre les échecs dans sa base de données locale et les rejoue en premier lors de l'exécution suivante. Ici, la correction a consisté à intégrer la règle au modèle ; lorsque ce n'est pas possible, le test vous alerte tout de même et la barrière bloque la mise en production.
Étape 5 : calibration et prédiction conforme
Un score de 0,8 devrait signifier qu'environ 80 % de ces demandeurs remboursent. Les réseaux de neurones modernes sont souvent trop confiants [6] ; nos arbres étaient déjà bien calibrés (ECE 0,014). Si les vôtres ne le sont pas, CalibratedClassifierCV de scikit-learn ajuste une correction sur des données de test.
La prédiction conforme va plus loin : elle transforme les scores de n'importe quel modèle en ensembles de prédiction qui contiennent la vraie étiquette avec une probabilité choisie, ici 90 %, en supposant seulement que les nouvelles données sont échangeables avec les données de calibration (en gros, tirées de la même population) [7]. Il suffit de trois étapes avec NumPy.
"""Split conformal prediction in plain numpy: prediction sets with a coverage guarantee."""
import joblib
import numpy as np
from data import make_loans
model = joblib.load("model.joblib")
alpha = 0.10 # target: true label in the set 90% of the time
X_cal, y_cal = make_loans(2_000, seed=2) # calibration data, unseen in training
X_test, y_test = make_loans(10_000, seed=3)
# 1. Non-conformity score: 1 - probability the model gave to the true class
p_cal = model.predict_proba(X_cal)
scores = 1 - p_cal[np.arange(len(y_cal)), y_cal]
# 2. Finite-sample-corrected quantile of the calibration scores
n = len(scores)
qhat = np.quantile(scores, np.ceil((n + 1) * (1 - alpha)) / n, method="higher")
# 3. Prediction set: every class whose score is within qhat
p_test = model.predict_proba(X_test)
sets = (1 - p_test) <= qhat # boolean matrix, shape (n_test, 2)
covered = sets[np.arange(len(y_test)), y_test].mean()
size = sets.sum(axis=1)
print(f"qhat={qhat:.3f} empirical coverage={covered:.3f} (target {1 - alpha:.2f})")
print(f"singleton sets={np.mean(size == 1):.1%} both classes={np.mean(size == 2):.1%} empty={np.mean(size == 0):.1%}")
# The guarantee is an average over calibration draws, so check it over many draws
cov = []
for s in range(100, 150):
Xc, yc = make_loans(2_000, seed=s)
sc = 1 - model.predict_proba(Xc)[np.arange(len(yc)), yc]
q = np.quantile(sc, np.ceil((len(sc) + 1) * (1 - alpha)) / len(sc), method="higher")
cov.append(((1 - p_test) <= q)[np.arange(len(y_test)), y_test].mean())
print(f"over 50 calibration draws: mean coverage={np.mean(cov):.3f} min={np.min(cov):.3f} max={np.max(cov):.3f}")
$ python conformal.py
qhat=0.689 empirical coverage=0.897 (target 0.90)
singleton sets=49.7% both classes=50.3% empty=0.0%
over 50 calibration draws: mean coverage=0.899 min=0.885 max=0.913
Deux enseignements. Premièrement, la garantie est valable en moyenne sur les tirages de calibration, et non pour chacun d'eux : les tirages individuels allaient de 0,885 à 0,913, et la moyenne était de 0,899 sur un jeu de test fixe qui ajoute son propre bruit. Deuxièmement, et c'est plus utile pour le métier, la moitié des demandeurs obtiennent l'ensemble {repay, default} : le modèle ne peut pas trancher avec un niveau de confiance de 90 %. C'est votre file de revue humaine, et sa taille est un coût que vous pouvez désormais chiffrer.
MAPIE encapsule la même méthode, avec davantage de scores de conformité et la prise en charge de la régression. La version 1 a modifié l'API ; voici la forme 1.x [8] :
"""The same thing with MAPIE 1.x (prefit model, LAC score)."""
import joblib
import numpy as np
from mapie.classification import SplitConformalClassifier
from data import make_loans
X_cal, y_cal = make_loans(2_000, seed=2)
X_test, y_test = make_loans(10_000, seed=3)
mapie = SplitConformalClassifier(estimator=joblib.load("model.joblib"),
confidence_level=0.90, prefit=True)
mapie.conformalize(X_cal, y_cal)
_, sets = mapie.predict_set(X_test) # sets: (n, n_classes, n_confidence_levels)
sets = sets[:, :, 0]
print(f"MAPIE coverage={sets[np.arange(len(y_test)), y_test].mean():.3f} "
f"mean set size={sets.sum(axis=1).mean():.2f}")
MAPIE coverage=0.897 mean set size=1.50
Même couverture, même taille moyenne d'ensemble (moitié de singletons, moitié de paires) : la version NumPy et la bibliothèque concordent.
Étape 6 : contrats de sortie et évaluations de non-régression pour une étape LLM
La sortie d'un LLM est du texte ; votre système a besoin de données. Traitez chaque réponse comme une entrée non fiable. Pydantic valide la structure (types, valeurs autorisées, champs obligatoires) et vous permet d'ajouter des contrôles métier déterministes, comme « montant HT plus TVA égale total » [9].
"""An output contract for an LLM step: schema, deterministic business checks, and a regression eval."""
import json
from datetime import date
from typing import Literal
from pydantic import BaseModel, Field, ValidationError, field_validator, model_validator
class InvoiceExtraction(BaseModel):
supplier: str = Field(min_length=2, max_length=120)
invoice_date: date
currency: Literal["GBP", "EUR", "USD"]
net: float = Field(ge=0)
vat: float = Field(ge=0)
total: float = Field(gt=0)
@field_validator("invoice_date")
@classmethod
def not_in_future(cls, v: date) -> date:
if v > date.today():
raise ValueError("invoice date is in the future")
return v
@model_validator(mode="after")
def totals_add_up(self):
if abs(self.net + self.vat - self.total) > 0.01:
raise ValueError(f"net + vat = {self.net + self.vat:.2f} but total = {self.total:.2f}")
return self
def check(raw: str) -> tuple[bool, str]:
"""Never trust the model's text: parse, validate, and say exactly what failed."""
try:
InvoiceExtraction.model_validate_json(raw)
return True, "ok"
except ValidationError as e:
return False, "; ".join(f"{'.'.join(map(str, err['loc'])) or 'model'}: {err['msg']}"
for err in e.errors())
# Three outputs an LLM really might produce for the same invoice
outputs = {
"good": '{"supplier":"Acme Ltd","invoice_date":"2026-10-31","currency":"GBP","net":100.0,"vat":20.0,"total":120.0}',
"bad_maths": '{"supplier":"Acme Ltd","invoice_date":"2026-10-31","currency":"GBP","net":100.0,"vat":20.0,"total":102.0}',
"bad_shape": '{"supplier":"Acme Ltd","invoice_date":"31/10/2026","currency":"£","net":"100","vat":20.0}',
}
if __name__ == "__main__":
for name, raw in outputs.items():
ok, why = check(raw)
print(f"{name:<10} {'PASS' if ok else 'FAIL'} {why}")
$ python llm_contract.py
good PASS ok
bad_maths FAIL model: Value error, net + vat = 120.00 but total = 102.00
bad_shape FAIL invoice_date: Input should be a valid date or datetime, invalid character in year; currency: Input should be 'GBP', 'EUR' or 'USD'; total: Field required
Remarquez ce qui n'a pas été signalé : "net":"100", une chaîne, a été accepté et converti, car le mode souple par défaut de Pydantic convertit les chaînes numériques. Si vous voulez que le modèle produise des types exacts, définissez model_config = ConfigDict(strict=True). Orientez ensuite les échecs : réessayez une fois avec le message d'erreur dans le prompt, et confiez les échecs répétés à une personne.
La validation prouve la forme, pas la véracité. Pour la véracité, il vous faut un jeu de référence : des cas réels dont les réponses ont été vérifiées par une personne, évalués champ par champ et comparés à la version en production avant que toute modification de prompt ou de modèle ne soit déployée.
"""Regression eval for an LLM step: golden cases, field-level scoring, compared against the last release."""
import json
import sys
from llm_contract import InvoiceExtraction, check
GOLDEN = [ # expected fields per case, written and reviewed by a person
{"id": "inv-001", "expect": {"supplier": "Acme Ltd", "total": 120.0, "currency": "GBP"}},
{"id": "inv-002", "expect": {"supplier": "Brightwater plc", "total": 54.0, "currency": "GBP"}},
{"id": "inv-003", "expect": {"supplier": "Nordlicht GmbH", "total": 238.0, "currency": "EUR"}},
{"id": "inv-004", "expect": {"supplier": "Kestrel Ltd", "total": 960.0, "currency": "GBP"}},
]
def extract(case_id: str, outputs: dict) -> str:
"""Replace with your model call (temperature 0, pinned model version, logged prompt)."""
return outputs[case_id]
def run(outputs: dict) -> dict:
valid = fields_ok = fields_total = 0
for case in GOLDEN:
raw = extract(case["id"], outputs)
ok, _ = check(raw)
valid += ok
got = InvoiceExtraction.model_validate_json(raw).model_dump() if ok else {}
for k, v in case["expect"].items():
fields_total += 1
fields_ok += got.get(k) == v
return {"schema_valid": valid / len(GOLDEN), "field_accuracy": fields_ok / fields_total}
if __name__ == "__main__":
baseline = json.load(open("baseline.json")) # scores of the release in production
candidate = run(json.load(open(sys.argv[1]))) # recorded outputs of the new prompt/model
print("baseline ", {k: round(v, 3) for k, v in baseline.items()})
print("candidate", {k: round(v, 3) for k, v in candidate.items()})
bad = [k for k in candidate if candidate[k] < baseline[k] - 0.02]
print("PASS" if not bad else f"FAIL: regression in {bad}")
sys.exit(1 if bad else 0)
$ python regression_eval.py outputs_v2.json
baseline {'schema_valid': 1.0, 'field_accuracy': 1.0}
candidate {'schema_valid': 0.75, 'field_accuracy': 0.667}
FAIL: regression in ['schema_valid', 'field_accuracy']
Ici, outputs_v1.json et outputs_v2.json contiennent des réponses enregistrées pour quatre factures (dans la v2, une devise est erronée et un total ne correspond pas), de sorte que l'exemple s'exécute sans clé d'API. Dans votre projet, extract() appelle le modèle avec une température de 0 et une version de modèle figée, et vous conservez les réponses brutes avec le score afin de pouvoir examiner un échec ultérieurement. Quatre cas suffisent pour une démonstration ; un jeu de référence utile en compte quelques centaines, choisis pour couvrir vos segments et vos incidents passés.
Étape 7 : surveillance de la dérive
Toutes les garanties ci-dessus supposent que les données de production ressemblent à vos données d'évaluation. Vérifiez que c'est toujours le cas. L'indice de stabilité de population (PSI) mesure le déplacement d'une distribution sur des intervalles fixes ; le test de Kolmogorov-Smirnov (KS) à deux échantillons détermine si deux échantillons peuvent provenir de la même distribution.
"""Drift checks on inputs and scores: population stability index and the two-sample KS test."""
import joblib
import numpy as np
from scipy.stats import ks_2samp
from data import make_loans, FEATURES
def psi(expected, actual, bins=10):
"""Population stability index over quantile bins of the reference data."""
edges = np.unique(np.quantile(expected, np.linspace(0, 1, bins + 1)))
edges[0], edges[-1] = -np.inf, np.inf
e = np.histogram(expected, edges)[0] / len(expected)
a = np.histogram(actual, edges)[0] / len(actual)
e, a = np.clip(e, 1e-6, None), np.clip(a, 1e-6, None)
return float(np.sum((a - e) * np.log(a / e)))
model = joblib.load("model.joblib")
X_ref, _ = make_loans(10_000, seed=1) # what the model was validated on
for label, shift in [("same population", 0.0), ("incomes 20% higher", np.log(1.2))]:
X_live, _ = make_loans(5_000, seed=7, income_shift=shift) # a week of production traffic
print(label)
for j, name in enumerate(FEATURES[:3]):
ks = ks_2samp(X_ref[:, j], X_live[:, j])
print(f" {name:<15} PSI={psi(X_ref[:, j], X_live[:, j]):.3f} KS p={ks.pvalue:.3g}")
s_ref, s_live = model.predict_proba(X_ref)[:, 1], model.predict_proba(X_live)[:, 1]
print(f" {'score':<15} PSI={psi(s_ref, s_live):.3f} mean {s_ref.mean():.3f} -> {s_live.mean():.3f}")
$ python drift.py
same population
income_k PSI=0.002 KS p=0.484
debt_ratio PSI=0.001 KS p=0.33
years_employed PSI=0.005 KS p=0.0319
score PSI=0.003 mean 0.572 -> 0.573
incomes 20% higher
income_k PSI=0.126 KS p=6.14e-59
debt_ratio PSI=0.001 KS p=0.33
years_employed PSI=0.005 KS p=0.0319
score PSI=0.066 mean 0.572 -> 0.627
Le revenu décalé est détecté par les deux mesures, et la distribution des scores se déplace avec lui. Mais regardez years_employed sur la même population : le test KS donne p = 0,03, « significatif » au seuil habituel de 5 %, alors que rien n'a changé. Exécutez suffisamment de tests chaque jour et certains se déclencheront par hasard ; avec de grands échantillons, de minuscules décalages sans conséquence deviennent eux aussi significatifs. Déclenchez les alertes sur des tailles d'effet comme le PSI (une règle empirique courante en notation de crédit considère qu'en dessous de 0,1 la distribution est stable et qu'au-dessus de 0,25 le décalage est important ; ajustez-la sur votre propre historique) et, surtout, sur les résultats réels dès que les étiquettes arrivent.
Étape 8 : vérification formelle d'un petit réseau
Pour un petit réseau ReLU, vous pouvez prouver des énoncés tels que « pour tout demandeur dont le revenu est compris entre 50 000 £ et 200 000 £, dont le taux d'endettement est au plus de 0,25 et quelle que soit son ancienneté dans l'emploi, le réseau indique un remboursement probable ». Deux méthodes, chacune en moins de 100 lignes :
- La propagation de bornes d'intervalles fait passer la boîte d'entrée à travers chaque couche. Elle est correcte (si elle indique que la propriété est vérifiée, c'est le cas) mais incomplète (elle peut échouer à prouver une propriété vraie, car les bornes sont larges).
- La programmation linéaire en nombres entiers mixtes encode chaque ReLU exactement à l'aide d'une variable binaire et demande à un solveur le véritable minimum de la sortie sur la boîte. Elle est complète, mais le problème est NP-complet en général [10] : elle ne s'applique donc qu'à de petits réseaux. La fonction
milpde SciPy utilise le solveur HiGHS [11].
"""Formal verification of a small ReLU network: interval bounds (fast, sound, incomplete)
and an exact mixed-integer program (complete) with scipy.optimize.milp."""
import sys
import numpy as np
from scipy.optimize import milp, LinearConstraint, Bounds
from sklearn.neural_network import MLPClassifier
from sklearn.preprocessing import StandardScaler
from data import make_loans
X, y = make_loans(20_000, seed=0)
X = X[:, :3] # income_k, debt_ratio, years_employed
scaler = StandardScaler().fit(X)
net = MLPClassifier(hidden_layer_sizes=(8, 8), activation="relu", max_iter=500,
random_state=0).fit(scaler.transform(X), y)
layers = list(zip(net.coefs_, net.intercepts_)) # last layer gives the logit
def to_scaled(lo, hi):
return (np.array(lo) - scaler.mean_) / scaler.scale_, (np.array(hi) - scaler.mean_) / scaler.scale_
def interval_bounds(lo, hi):
"""Push a box through the network; returns pre-activation bounds per layer."""
bounds = []
for k, (W, b) in enumerate(layers):
Wp, Wn = np.clip(W, 0, None), np.clip(W, None, 0)
l, u = lo @ Wp + hi @ Wn + b, hi @ Wp + lo @ Wn + b
bounds.append((l, u))
lo, hi = np.maximum(l, 0), np.maximum(u, 0)
return bounds
def min_logit_milp(lo, hi):
"""Exact minimum of the logit over the box. Each unstable ReLU a = max(z, 0) becomes
linear constraints plus one binary d (d=1: active), using the interval bounds l <= z <= u."""
pre = interval_bounds(lo, hi)
n_in = len(lo)
sizes = [W.shape[1] for W, _ in layers]
# variable layout: x | (z, a, d) per hidden layer | logit
idx, off = {}, n_in
for k, n in enumerate(sizes[:-1]):
idx[k] = (off, off + n, off + 2 * n); off += 3 * n
out = off; nv = off + 1
rows, lb, ub = [], [], []
def add(coef, l, u):
r = np.zeros(nv)
for i, c in coef: r[i] += c
rows.append(r); lb.append(l); ub.append(u)
prev = list(range(n_in))
for k, (W, b) in enumerate(layers):
if k == len(layers) - 1: # logit = W a + b
add([(prev[i], W[i, 0]) for i in range(len(prev))] + [(out, -1)], -b[0], -b[0])
break
z0, a0, d0 = idx[k]
l, u = pre[k]
for j in range(W.shape[1]):
add([(prev[i], W[i, j]) for i in range(len(prev))] + [(z0 + j, -1)], -b[j], -b[j])
add([(a0 + j, 1), (z0 + j, -1)], 0, np.inf) # a >= z
add([(a0 + j, 1), (d0 + j, -max(u[j], 0))], -np.inf, 0) # a <= u d
add([(a0 + j, 1), (z0 + j, -1), (d0 + j, -min(l[j], 0))], -np.inf, -min(l[j], 0)) # a <= z - l(1-d)
prev = list(range(a0, a0 + W.shape[1]))
vlo, vhi, integ = np.full(nv, -np.inf), np.full(nv, np.inf), np.zeros(nv)
vlo[:n_in], vhi[:n_in] = lo, hi
for k in idx:
z0, a0, d0 = idx[k]; n = sizes[k]
vlo[a0:a0 + n] = 0; vlo[d0:d0 + n] = 0; vhi[d0:d0 + n] = 1; integ[d0:d0 + n] = 1
c = np.zeros(nv); c[out] = 1 # minimise the logit
res = milp(c, constraints=LinearConstraint(np.array(rows), lb, ub),
integrality=integ, bounds=Bounds(vlo, vhi))
assert res.success, res.message # never report a bound from a failed solve
return res.fun, res.x[:n_in] * scaler.scale_ + scaler.mean_
# Property: every applicant in the box must be scored "likely to repay" (logit > 0).
# required=True boxes are policy; the last one is exploratory, to find where the policy stops holding.
PROPERTIES = [
("income 80-200k, debt <= 0.15, 5-30 yrs", [80, 0.0, 5], [200, 0.15, 30], True),
("income 50-200k, debt <= 0.25, 0-30 yrs", [50, 0.0, 0], [200, 0.25, 30], True),
("income 40-200k, debt <= 0.30, 0-30 yrs", [40, 0.0, 0], [200, 0.30, 30], False),
]
failed = False
for name, box_lo, box_hi, required in PROPERTIES:
lo, hi = to_scaled(box_lo, box_hi)
ibp_lower = interval_bounds(lo, hi)[-1][0][0]
exact, worst = min_logit_milp(lo, hi)
verdict = "VERIFIED" if exact > 0 else "COUNTEREXAMPLE"
if ibp_lower > 0:
verdict += " (intervals alone were enough)"
print(f"{name}\n interval lower bound={ibp_lower:+.3f} exact min logit={exact:+.3f} {verdict}")
if exact <= 0:
print(f" worst case: income {worst[0]:.1f}k, debt {worst[1]:.3f}, {worst[2]:.1f} yrs")
failed |= required
# cross-check the verifier: no random sample may beat the exact minimum
S = np.random.default_rng(0).uniform(box_lo, box_hi, (100_000, 3))
h = scaler.transform(S)
for W, b in layers[:-1]:
h = np.maximum(h @ W + b, 0)
print(f" lowest logit in 100,000 random samples={(h @ layers[-1][0] + layers[-1][1]).min():+.3f}")
sys.exit(1 if failed else 0) # a required property failed
$ python verify_tiny_net.py
income 80-200k, debt <= 0.15, 5-30 yrs
interval lower bound=+0.254 exact min logit=+1.942 VERIFIED (intervals alone were enough)
lowest logit in 100,000 random samples=+1.960
income 50-200k, debt <= 0.25, 0-30 yrs
interval lower bound=-1.573 exact min logit=+0.589 VERIFIED
lowest logit in 100,000 random samples=+0.626
income 40-200k, debt <= 0.30, 0-30 yrs
interval lower bound=-2.774 exact min logit=-0.273 COUNTEREXAMPLE
worst case: income 40.0k, debt 0.300, 0.0 yrs
lowest logit in 100,000 random samples=-0.231
Lisez les trois lignes. La première propriété est prouvée par les seuls intervalles. La deuxième est vraie, mais les intervalles ne pouvaient pas le montrer ; le solveur exact l'a pu. La troisième est fausse, et le solveur renvoie le pire demandeur, un contre-exemple concret à discuter avec le métier. L'échantillonnage aléatoire s'est approché du vrai minimum à chaque fois sans jamais l'atteindre, c'est pourquoi l'échantillonnage est un contrôle de cohérence et non une preuve.
Les limites : ce réseau compte 16 neurones cachés. Pour des réseaux plus grands, utilisez un vérificateur dédié : α,β-CROWN, qui a remporté VNN-COMP chaque année de 2021 à 2025 et annonce passer à l'échelle de réseaux convolutifs comptant des millions de paramètres pour des propriétés locales, ou Marabou [12][13]. Aucun d'eux ne prouve quoi que ce soit sur les réponses d'un grand modèle de langage. Et une preuve ne couvre qu'une version de modèle et une boîte d'entrée : relancez-la à chaque réentraînement, dans la barrière.
Étape 9 : la barrière de mise en production en CI
Des éléments probants dont l'application n'est pas imposée se dégradent. gate.sh exécute tout ce qui précède et s'arrête au premier échec :
#!/usr/bin/env bash
# Release gate: every check must pass before a model or prompt change can ship.
set -euo pipefail
export OMP_NUM_THREADS=1 # stop OpenMP oversubscription in per-row tests
python model.py
python eval_harness.py model.joblib # held-out + slice contract
python -m pytest -q test_properties.py # properties and metamorphic relations
python conformal.py # coverage report (informational)
python regression_eval.py outputs_v1.json # LLM step: no regression against production
python verify_tiny_net.py # formal check: required boxes must verify
echo "ALL GATES PASSED"
Un workflow GitHub Actions minimal qui l'exécute sur chaque pull request (présenté pour illustrer la structure ; nous avons exécuté gate.sh en local, pas dans Actions) :
name: model-gate
on: [pull_request]
jobs:
gate:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v7
- uses: actions/setup-python@v7
with: { python-version: "3.12" }
- run: pip install numpy scipy scikit-learn hypothesis pydantic pytest mapie
- run: ./gate.sh
- uses: actions/upload-artifact@v7
if: always()
with: { name: evidence, path: eval_report.json }
Mise en production
- Figez tout. Figez les versions des bibliothèques dans un fichier de verrouillage et consignez dans
eval_report.jsonl'empreinte de l'artefact du modèle, l'instantané des données et le commit git. Un rapport que vous ne pouvez pas relier à une version de modèle ne constitue pas un élément probant. - Conteneurs. Exécutez la barrière dans l'image même que vous déployez, afin que les tests utilisent les mêmes builds de NumPy et de scikit-learn que la production. Tout cela s'exécute sur CPU ; les tests de propriétés et le vérificateur se sont terminés en quelques secondes sur un ordinateur portable.
- Threads. Définissez
OMP_NUM_THREADSde manière délibérée, en CI comme en service. Sur notre machine de build partagée, une prédiction sur une seule ligne prenait 150 ms avec le threading par défaut et 1,3 ms avec un seul thread. - Supervision. Planifiez
drift.pysur un échantillon quotidien d'entrées et de scores journalisés, exportez le PSI de chaque variable sous forme de métriques vers votre pile de supervision existante, et alertez par le circuit d'astreinte habituel. Rapprochez les résultats réels des prédictions lorsque les étiquettes arrivent et relancez le banc d'évaluation sur ces données. - Pour aller plus loin. Le ML Test Score de Google recense 28 tests et contrôles de supervision pour la préparation à la production, et constitue un bon audit de ce qui vous a échappé [17] ; Sculley et al. expliquent pourquoi les pipelines de données et le code d'intégration qui entourent un modèle exigent le même soin que le modèle lui-même [16].
- Conservez la trace. Stockez la sortie de chaque exécution de la barrière avec la version publiée. Lorsqu'un auditeur ou un client vous demande comment vous saviez que le modèle était apte à l'usage, c'est la réponse.
Pièges et débogage
- Les tests Hypothesis sont très lents. Surabonnement des threads dans OpenMP ; définissez
OMP_NUM_THREADS=1. Définissez aussideadline=None, car les appels au modèle ont une latence variable. - Un test de propriété échoue sur une différence minime. Bruit de virgule flottante ; comparez avec une tolérance (nous utilisons 1e-9) et déterminez quelle différence compte pour le métier.
- La couverture conforme est inférieure à la cible. C'est possible pour un tirage de calibration isolé ; vérifiez la moyenne sur plusieurs tirages. Si elle est nettement inférieure, vos données de calibration ne sont pas échangeables avec la production, souvent en raison d'une tendance temporelle : calibrez sur des données récentes.
- Le MILP est lent ou échoue. Resserrez les bornes d'entrée, car des bornes larges produisent des encodages faibles, et vérifiez
res.success. Au-delà de quelques centaines de neurones, passez à un vérificateur dédié. - L'évaluation de non-régression LLM est instable. Fixez la température à 0, figez la version du modèle et, si les sorties varient encore, exécutez chaque cas plusieurs fois et appliquez la barrière sur le taux de réussite.
Comment évaluer les éléments probants eux-mêmes
Testez vos tests. Introduisez un défaut connu et vérifiez que la barrière le détecte : le modèle sans contraintes en est précisément un pour les tests de propriétés, outputs_v2.json en est un pour l'évaluation LLM, et les revenus décalés en sont un pour la dérive. Conservez ces défauts introduits dans le dépôt et exécutez-les en CI comme des tests censés échouer, afin qu'un contrôle défaillant ne puisse pas réussir en silence.
Alternatives
| Besoin | Ce que nous avons utilisé | Alternatives | Quand changer |
|---|---|---|---|
| Banc d'évaluation | scikit-learn et NumPy seuls | Évaluation MLflow, fonctions d'évaluation de votre outil de suivi d'expériences | Nombreux modèles et équipes ; vous avez besoin d'une interface et d'un historique |
| Tests de propriétés | Hypothesis | CheckList (tests comportementaux pour le NLP) | Modèles de texte dont les perturbations sont linguistiques |
| Incertitude | Prédiction conforme par partition avec NumPy, MAPIE | CalibratedClassifierCV pour la seule calibration | Vous avez besoin de scores calibrés, pas d'ensembles |
| Sortie LLM | Pydantic plus un jeu de référence | Modes de sortie structurée des fournisseurs, frameworks d'évaluation de LLM | Nombreux prompts ; vous voulez des tableaux de bord et une évaluation par LLM-juge |
| Dérive | PSI et KS avec SciPy | Evidently et bibliothèques de supervision similaires | Nombreuses variables ; vous voulez des rapports et des tableaux de bord |
| Vérification | Bornes d'intervalles et MILP de SciPy | α,β-CROWN, Marabou | Réseaux au-delà de quelques centaines de neurones |
FAQ
Est-ce suffisant pour l'AI Act de l'UE ? Cela produit le type d'éléments probants que demandent les articles 9 et 15 (tests au regard de métriques définies au préalable et de seuils probabilistes, précision déclarée, robustesse), mais la conformité exige aussi des processus de gestion des risques, de gouvernance des données, de documentation et de contrôle humain [14]. Depuis l'Omnibus numérique, les obligations relatives aux systèmes à haut risque autonomes de l'annexe III s'appliquent à partir du 2 décembre 2027 [15].
Ai-je besoin de tout cela pour chaque modèle ? Non. Adaptez l'effort au risque : un moteur de classement de recherche interne peut nécessiter les étapes 3, 6 et 7 ; une décision de crédit les exige toutes, plus une validation indépendante.
Puis-je vérifier formellement un LLM ? Pas ses réponses. Vous pouvez vérifier le code déterministe qui l'entoure, contraindre le format de sa sortie et vérifier les petits classificateurs placés à côté de lui, comme un routeur ou un modèle de garde.
Pourquoi des données synthétiques ? Pour que chaque test ait une bonne réponse connue. Remplacez-les par vos données en conservant la structure ; les seuils du contrat changeront.
Si vous souhaitez de l'aide pour mettre en place des bancs d'évaluation, des barrières de mise en production et une supervision autour de vos propres modèles, découvrez notre service de mise en place MLOps.
Références
- Guide de l'utilisateur de scikit-learn : gradient boosting à base d'histogrammes, contraintes monotones
- D'Amour et al., « Underspecification presents challenges for credibility in modern machine learning », arXiv 2011.03395 (JMLR, 2022)
- Documentation d'Hypothesis
- Chen et al., « Metamorphic testing: a review of challenges and opportunities », ACM Computing Surveys, 2018
- Ribeiro et al., « Beyond accuracy: behavioral testing of NLP models with CheckList », ACL 2020
- Guo et al., « On calibration of modern neural networks », ICML 2017
- Angelopoulos et Bates, « A gentle introduction to conformal prediction and distribution-free uncertainty quantification », arXiv 2107.07511
- Documentation de MAPIE
- Documentation de Pydantic : validateurs
- Katz et al., « Reluplex: an efficient SMT solver for verifying deep neural networks », CAV 2017
- Documentation de SciPy : scipy.optimize.milp
- Vérificateur de réseaux de neurones α,β-CROWN (GitHub)
- Vérificateur de réseaux de neurones Marabou (GitHub)
- Règlement (UE) 2024/1689 (règlement sur l'intelligence artificielle)
- Omnibus numérique sur l'IA, règlement (UE) 2026/1744 : AI Act Explorer
- Sculley et al., « Hidden technical debt in machine learning systems », NeurIPS 2015
- Breck et al., « The ML Test Score: a rubric for ML production readiness and technical debt reduction », IEEE Big Data 2017