La boutique est ouverte

Nous construisons les machines Workstation AI pour les sites web, les agents IA et l'entraînement de LLM — configurez-les et achetez-les en ligne.

Obtenir les prix pro
Produits IA
Labs IAAgents OpenAIAgents ClaudeGrok BotCRM natif Workstation AIMarketingTous les produits
Solutions IA
IA appliquéeAgents IAIA générativeAutomatisation par IAMontée en compétence IAOffres IA pour PMELaboratoire IA d'entrepriseStations de travail IAMatériel et logiciels NVIDIACalcul accéléré NVIDIAIA privéeCloud privé GPUClusters GPUIA en périphérieIA par secteur
Services IA
Modernisation des plateformesIngénierie numériqueFondations data et IAOpérations autonomesConseil IAAutomatisation DevOpsCybersécuritéDéveloppement logicielCréation d'agentsMise en place MLOpsLocation de GPUCloud privé GPU
À propos
EntrepriseNotre histoirePartenairesTémoignages clients
Centres de données IA
Centres de données IACloud privé GPUClusters GPULocation de GPU
Analyses IASérie JevLabo de benchmarksChoix de modèles
Notes techniques
Documentation
OS LinuxUbuntuRed Hat Enterprise LinuxSUSE LinuxAlpine LinuxDebian, Rocky & AlmaLinux
Plateformes cloud d'IAAWS & Amazon BedrockGoogle Cloud & Vertex AIMicrosoft Azure & AI FoundryClouds et places de marché GPU
Centres de données IA privésPour les cabinets d'avocatsPour les cabinets comptablesPlateformes sur siteCloud entièrement sécurisé
OutilsRing PromoterJobshout
Actualités
Blog
Nous contacterSe connecter

Stations de travail IA, logiciels multi-agents IA, infrastructure GPU et solutions d'agents intelligents pour les entreprises modernes.

Nous contacter

Solutions IA

IA appliquéeAgents IAIA générativeAutomatisation par IAMontée en compétence IAOffres IA pour PMELaboratoire IA d'entrepriseIA par secteur

Produits

Tous les produitsCRM & ERP natifs Workstation AIMarketingAgents OpenAIRing PromoterJobshout

Entreprise

À proposEntrepriseCentres de données IAPourquoi WorkstationPartenairesTémoignages clientsTarifsContactTenthMatrix

Ressources

Analyses IANotes techniquesDocumentationOS LinuxPlateformes cloud d'IACentres de données IA privésBlogRechercherPlan du site
Siège social au Royaume-Uni
77-79 Marlowes, Hemel Hempstead HP1 1LFItinéraire : prenez la sortie 20 de la M25, Outer LondonN° d'entreprise: 11641870Lun - Ven : 9h00 - 18h00 GMT
+44 7515 356 146
Bureau de Belgique
Workstation SRL, Rue Vanderkindere 34, 1180 Uccle, BrusselsBE 0751.518.683Lun - Ven : 9h00 - 18h00 CET
+32 492 45 67 46
Bureau de l'Inde
#159 Sector 9, Pocket 1, DDA Flats, 110077 Dwarka, New Delhi
+91 98881 98841
Bureau de Taïwan
3F, No. 2-4, Aisi Rd., Ren'ai Dist., Keelung City 200, Taiwan基隆市仁愛區愛四路2之4號3樓Lun - Ven : 9 h 00 - 18 h 00, heure de Taïwan (GMT+8)
+886 926 892 701+32 492 45 67 46
Bureau en Estonie
Aleksander Puškini tn 30-25, 20306 Narva, EstoniaLun - Ven : 9 h 00 - 18 h 00, heure d’Estonie (EET)
+32 492 45 67 46

© 2026 Workstation AI. Tous droits réservés.

ConfidentialitéSuppression des donnéesCookiesConditions d'utilisationPlan du site web

NVIDIA, le logo NVIDIA, RTX, RTX PRO, Blackwell, CUDA, NVLink, MGX, Omniverse, Spectrum-X, Quantum, BlueField, DGX et HGX sont des marques commerciales et/ou des marques déposées de NVIDIA Corporation aux États-Unis et dans d'autres pays. AMD, le logo AMD Arrow, EPYC, Instinct, Ryzen et Threadripper sont des marques commerciales d'Advanced Micro Devices, Inc. Dell et PowerEdge sont des marques commerciales de Dell Inc. ou de ses filiales. Intel et Xeon sont des marques commerciales d'Intel Corporation ou de ses filiales. AMAX, AceleMax et LiquidMax sont des marques commerciales d'AMAX Engineering Corporation. Tous les autres noms de produits, logos et marques appartiennent à leurs propriétaires respectifs. Nous les utilisons uniquement pour identifier les produits que nous décrivons, fournissons ou prenons en charge ; leur utilisation ne signifie pas que leurs propriétaires nous cautionnent.

Accueil / Notes techniques / Technology
AIMLOpsLLMPython

Tester des systèmes ML et LLM impossibles à prouver corrects : une boîte à outils Python d'éléments probants

Des éléments probants à la place des preuves, en environ 400 lignes de Python avec une sortie réelle : métriques par segment avec intervalles bootstrap et contrat de réussite ou d'échec, tests de propriétés et métamorphiques avec Hypothesis, calibration et prédiction conforme, contrats Pydantic et évaluations de non-régression pour les sorties LLM, contrôles de dérive, barrière en CI et vérification exacte d'un petit réseau de neurones

16 novembre 2026Technology30 min read

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.

Un terminal exécutant une barrière de mise en production : évaluation PASS, quatre tests de propriétés réussis, couverture conforme 0,897, non-régression LLM PASS, deux propriétés vérifiées et un contre-exemple, se terminant par ALL GATES PASSED.

Synthèse. Vous ne pouvez pas prouver qu'un modèle est correct, car il n'existe pas de spécification complète par rapport à laquelle le prouver. Vous pouvez en revanche produire des éléments montrant qu'il est suffisamment fiable, et continuer à les produire : des métriques convenues avec des intervalles de confiance par segment, des tests de règles qui doivent être vérifiées pour toute entrée, une incertitude assortie d'une couverture déclarée, des sorties LLM validées, des alertes de dérive et une barrière qui bloque les mises en production lorsque l'un de ces contrôles échoue. Lorsqu'un petit réseau prend une décision bornée et à fort enjeu, vous pouvez aussi vérifier des propriétés de manière exacte. Le résultat phare de notre exécution : deux modèles ayant exactement la même AUC sur les données de test, 0,747, se sont comportés différemment, et seul un test de propriété a permis de les distinguer.

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.

Sept couches d'éléments probants, du plus large au plus étroit : métriques sur données de test, métriques par segment, tests de propriétés et métamorphiques, calibration et prédiction conforme, contrats de sortie LLM, surveillance de la dérive et vérification formelle de petits réseaux, chacune avec le fichier qui la produit.
Les éléments probants que vous allez construire, un fichier par couche. Les couches inférieures couvrent une plus grande partie du système avec des garanties plus faibles ; la vérification formelle offre la garantie la plus forte sur le périmètre le plus restreint.

É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.

Prédiction conforme par partition : calculer les scores du jeu de calibration, prendre le 90e centile corrigé des scores de non-conformité comme qhat égal à 0,689, puis inclure chaque classe dont le score se situe dans qhat. Les cas sûrs obtiennent une seule étiquette ; les cas incertains obtiennent les deux et passent en revue humaine.
La prédiction conforme par partition en trois étapes. Les cas incertains obtiennent les deux étiquettes et sont confiés à une personne ; la part de ces cas (50,3 % ici) est un chiffre que vous pouvez présenter au métier.

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 milp de 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
Trois droites numériques, une par boîte d'entrée, comparant à zéro la borne inférieure par intervalles, le minimum exact du solveur et la plus petite valeur de 100 000 échantillons aléatoires. Boîte un : tout est au-dessus de zéro. Boîte deux : la borne par intervalles est sous zéro mais le minimum exact au-dessus, donc vérifiée. Boîte trois : le minimum exact est sous zéro, un contre-exemple.
Les bornes d'intervalles sont rapides mais larges ; le solveur exact tranche le cas intermédiaire. L'échantillonnage aléatoire ne descend jamais sous le minimum exact, ce qui permet de vérifier utilement que l'encodage est correct, mais l'échantillonnage seul ne pourrait jamais prouver la propriété.

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 }
Une version candidate franchit tour à tour cinq barrières : contrat d'évaluation, tests de propriétés, rapport de couverture conforme, évaluation de non-régression LLM et vérification formelle. Une version candidate qui échoue à l'une d'elles est arrêtée et le rapport est conservé.
La barrière en CI : un modèle ou un prompt candidat passe chaque contrôle dans l'ordre ; tout échec l'arrête, et les rapports sont conservés comme dossier de mise en production.

Mise en production

  • Figez tout. Figez les versions des bibliothèques dans un fichier de verrouillage et consignez dans eval_report.json l'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_THREADS de 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.py sur 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 aussi deadline=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

BesoinCe que nous avons utiliséAlternativesQuand changer
Banc d'évaluationscikit-learn et NumPy seulsÉvaluation MLflow, fonctions d'évaluation de votre outil de suivi d'expériencesNombreux modèles et équipes ; vous avez besoin d'une interface et d'un historique
Tests de propriétésHypothesisCheckList (tests comportementaux pour le NLP)Modèles de texte dont les perturbations sont linguistiques
IncertitudePrédiction conforme par partition avec NumPy, MAPIECalibratedClassifierCV pour la seule calibrationVous avez besoin de scores calibrés, pas d'ensembles
Sortie LLMPydantic plus un jeu de référenceModes de sortie structurée des fournisseurs, frameworks d'évaluation de LLMNombreux prompts ; vous voulez des tableaux de bord et une évaluation par LLM-juge
DérivePSI et KS avec SciPyEvidently et bibliothèques de supervision similairesNombreuses variables ; vous voulez des rapports et des tableaux de bord
VérificationBornes d'intervalles et MILP de SciPyα,β-CROWN, MarabouRé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

  1. Guide de l'utilisateur de scikit-learn : gradient boosting à base d'histogrammes, contraintes monotones
  2. D'Amour et al., « Underspecification presents challenges for credibility in modern machine learning », arXiv 2011.03395 (JMLR, 2022)
  3. Documentation d'Hypothesis
  4. Chen et al., « Metamorphic testing: a review of challenges and opportunities », ACM Computing Surveys, 2018
  5. Ribeiro et al., « Beyond accuracy: behavioral testing of NLP models with CheckList », ACL 2020
  6. Guo et al., « On calibration of modern neural networks », ICML 2017
  7. Angelopoulos et Bates, « A gentle introduction to conformal prediction and distribution-free uncertainty quantification », arXiv 2107.07511
  8. Documentation de MAPIE
  9. Documentation de Pydantic : validateurs
  10. Katz et al., « Reluplex: an efficient SMT solver for verifying deep neural networks », CAV 2017
  11. Documentation de SciPy : scipy.optimize.milp
  12. Vérificateur de réseaux de neurones α,β-CROWN (GitHub)
  13. Vérificateur de réseaux de neurones Marabou (GitHub)
  14. Règlement (UE) 2024/1689 (règlement sur l'intelligence artificielle)
  15. Omnibus numérique sur l'IA, règlement (UE) 2026/1744 : AI Act Explorer
  16. Sculley et al., « Hidden technical debt in machine learning systems », NeurIPS 2015
  17. Breck et al., « The ML Test Score: a rubric for ML production readiness and technical debt reduction », IEEE Big Data 2017
Partager cet article

Plus dans Technology

Portables pour développeurs IA : exécuter des LLM en local sous Linux avec des GPU de 16 GB et 24 GB (guide 2026)

Portables pour développeurs IA : exécuter des LLM en local sous Linux avec des GPU de 16 GB et 24 GB (guide 2026)

Ce qui tient sur un GPU RTX 5080 ou RTX 5090 Laptop, le calcul de mémoire, les modèles ouverts qui valent la peine, la configuration d'Ubuntu 26.04 avec la pile NVIDIA, Ollama, llama.cpp et vLLM, les assistants de code, l'affinage LoRA, la sécurité, et quand passer le travail sur un serveur

Lire la suite
TorchCurves en pratique : courbes B-spline et de Legendre apprenables dans PyTorch

TorchCurves en pratique : courbes B-spline et de Legendre apprenables dans PyTorch

Installer torchcurves, ajuster et dimensionner une courbe, choisir entre B-spline et Legendre ainsi que l’application d’entrée, construire une courbe de calibration monotone et un modèle additif sur des données tabulaires, comparer avec SciPy, scikit-learn, un KAN et un MLP, exporter les coefficients en JSON, tester et exploiter en production, avec des sorties réelles

Lire la suite
Exécuter des modèles agentiques, vocaux et de vision sur l'appareil avec Cactus : guide pratique (2026)

Exécuter des modèles agentiques, vocaux et de vision sur l'appareil avec Cactus : guide pratique (2026)

Installer cactus-compute, effectuer des appels d'outils, filtrer par niveau de confiance avec repli vers un modèle plus grand, extraire des données structurées, exécuter la parole et la vision, mesurer la latence et la mémoire, et livrer un conteneur hors ligne, avec chaque exemple exécuté et une comparaison avec llama.cpp, ONNX Runtime, ExecuTorch, MLC LLM et TensorRT Edge-LLM

Lire la suite