Tracer une bande entre les quantiles 0,1 et 0,9 lui donne un niveau nominal de 80 %. Il reste à vérifier combien de nouvelles observations elle contient effectivement. Dans notre exemple Python, elle couvre 487 cas sur 600, soit 81,17 %. Ce résultat décrit ce lot de test ; il ne garantit pas une couverture de 80 % à chaque valeur de la variable d’entrée.
Ce cas prolonge le guide de régression quantile avec une procédure de contrôle : couverture, largeur, croisements et lecture par sous-groupes. Télécharger le code, les prédictions et les six tests (ZIP gratuit).
Ce que signifie une couverture à 80 %
Si les vrais quantiles conditionnels étaient connus pour une cible continue, l’intervalle entre 0,1 et 0,9 contiendrait 80 % de sa distribution conditionnelle. Un modèle ne connaît pas ces quantiles : il les estime à partir d’un échantillon. Une belle bande sur un graphique ne vérifie donc pas sa qualité.
La couverture empirique est le nombre de cibles situées entre les deux bornes, bornes incluses ici, divisé par le nombre d’observations évaluées. L’exemple officiel de scikit-learn sur les intervalles quantiles illustre le calcul sur un lot indépendant. Notre mécanisme, nos modèles et nos chiffres sont ceux de l’expérience ci-dessous.
Cet intervalle concerne la variabilité d’une observation de la cible. Ce n’est pas un intervalle de confiance de la moyenne, ni un intervalle de confiance autour du pourcentage de couverture mesuré. Et couvrir davantage de points ne suffit pas à rendre une bande utile : une bande démesurément large serait facile à couvrir.
Un problème synthétique avec un bruit croissant
Nous tirons 2 400 valeurs de x entre 0 et 10. La cible vaut 15 + 2x + 5 sin(x), plus un bruit normal multiplié par 0.6 + 0.5x. Le bruit est donc plus fort à droite qu’à gauche. Les deux variables sont artificielles et sans unité ; aucune prévision réelle n’est présentée.
Le protocole réserve 1 200 lignes à l’apprentissage, 600 à la validation et 600 au test. Deux modèles HistGradientBoostingRegressor apprennent les quantiles 0,1 et 0,9. Nous comparons des arbres limités à 4 ou 12 feuilles, avec 150 itérations et les autres réglages fixés. L’arrêt anticipé automatique est désactivé pour conserver ce protocole explicite.
La validation choisit le nombre de feuilles qui minimise la moyenne des deux pertes pinball. Le candidat à 4 feuilles obtient 0,5391, contre 0,5597 pour celui à 12 feuilles. Le choix est figé avant de regarder la couverture de test. Nous n’élargissons pas la bande après avoir observé ses erreurs de test.
Compter les cas couverts et mesurer les largeurs
Pour une observation, le contrôle est simplement borne_basse <= cible <= borne_haute. Nous vérifions aussi que la borne basse ne dépasse pas la borne haute. Des modèles de quantiles entraînés séparément peuvent produire ce croisement ; le script le signale au lieu de réordonner silencieusement les bornes.
| Population | Effectif | Couverts | Couverture | Largeur moyenne | Croisements |
|---|---|---|---|---|---|
| Ensemble | 600 | 487 | 81,17 % | 7,759 | 0 |
| x < 5 | 320 | 267 | 83,44 % | 4,719 | 0 |
| x ≥ 5 | 280 | 220 | 78,57 % | 11,233 | 0 |
La largeur augmente dans la zone où nous avons ajouté davantage de bruit, ce qui correspond au mécanisme du jeu. La couverture globale est proche du niveau nominal. Les sous-groupes diffèrent d’environ 4,9 points, mais cet écart sur un seul tirage ne démontre pas une différence durable. Les effectifs doivent toujours accompagner les pourcentages.

Les pertes pinball de test sont 0,5385 pour le quantile bas et 0,5479 pour le haut. Elles complètent le comptage en tenant compte de la position des prédictions de quantiles. La couverture seule ne distingue pas correctement une bande informative d’une bande inutilement large.
Le code Python complet
Exécuté avec Python 3.12.14, NumPy 2.5.3 et scikit-learn 1.9.1. Le ZIP comprend le générateur, le fichier predictions-test.csv, les résultats JSON, la figure et les dépendances directes.
python -m pip install -r requirements.txt
python quantiles_couverture.py
python test_exemple.py
python figure.py
"""Un intervalle nominal à 80 % doit être évalué sur des observations réservées."""
from pathlib import Path
import csv,json
import numpy as np
from sklearn.ensemble import HistGradientBoostingRegressor
from sklearn.metrics import mean_pinball_loss
from sklearn.model_selection import train_test_split
QUANTILES = (.1, .9)
def donnees():
rng = np.random.default_rng(42)
X = rng.uniform(0, 10, (2400, 1))
x = X[:, 0]
y = 15 + 2 * x + 5 * np.sin(x) + (.6 + .5 * x) * rng.normal(size=len(x))
train_dev, test = train_test_split(np.arange(len(y)), test_size=.25, random_state=42)
train, val = train_test_split(train_dev, test_size=1/3, random_state=42)
return X, y, train, val, test
def mesurer(y, bas, haut):
croises = bas > haut
dedans = (y >= bas) & (y <= haut)
largeurs_valides = (haut - bas)[~croises]
return {'n': len(y), 'couverts': int(dedans.sum()), 'couverture': float(dedans.mean()),
'croisements': int(croises.sum()),
'largeur_moyenne_non_croisee': float(largeurs_valides.mean()) if len(largeurs_valides) else None,
'pinball_01': float(mean_pinball_loss(y, bas, alpha=.1)),
'pinball_09': float(mean_pinball_loss(y, haut, alpha=.9))}
def selectionner(X_train, y_train, X_val, y_val):
candidats = []
for feuilles in (4, 12):
modeles = [HistGradientBoostingRegressor(loss='quantile', quantile=q,
max_leaf_nodes=feuilles, max_iter=150, learning_rate=.06,
min_samples_leaf=25, early_stopping=False, random_state=42).fit(X_train, y_train)
for q in QUANTILES]
perte = np.mean([mean_pinball_loss(y_val, m.predict(X_val), alpha=q)
for q, m in zip(QUANTILES, modeles)])
candidats.append((float(perte), feuilles, modeles))
meilleur = min(candidats, key=lambda e: e[0])
return meilleur[2], meilleur[1], [{'max_leaf_nodes': c[1], 'pinball_validation': c[0]} for c in candidats]
def experience():
X, y, train, val, test = donnees()
modeles, feuilles, candidats = selectionner(X[train], y[train], X[val], y[val])
# Choix gelé avant de lire la couverture de test ; pas de correction après coup.
bas, haut = [m.predict(X[test]) for m in modeles]
groupes = {}
for nom, masque in [('x_inferieur_a_5', X[test, 0] < 5), ('x_superieur_ou_egal_a_5', X[test, 0] >= 5)]:
groupes[nom] = mesurer(y[test][masque], bas[masque], haut[masque])
resume = {'donnees': 'synthétiques', 'niveau_nominal': .8, 'max_leaf_nodes': feuilles,
'tailles': {'train': len(train), 'validation': len(val), 'test': len(test)},
'candidats': candidats, 'test': mesurer(y[test], bas, haut), 'groupes_test': groupes}
return {'X': X, 'y': y, 'train': train, 'val': val, 'test': test,
'modeles': modeles, 'bas': bas, 'haut': haut, 'resume': resume}
if __name__ == '__main__':
r = experience()
out = Path(__file__).resolve().parent
(out / 'resultats.json').write_text(json.dumps(r['resume'], indent=2, ensure_ascii=False), encoding='utf-8')
with (out / 'predictions-test.csv').open('w', newline='', encoding='utf-8') as f:
w = csv.writer(f)
w.writerow(['id_observation', 'x', 'cible', 'q10', 'q90', 'couverte', 'croisement'])
for i, bas, haut in zip(r['test'], r['bas'], r['haut']):
w.writerow([int(i), r['X'][i, 0], r['y'][i], bas, haut,
int(bas <= r['y'][i] <= haut), int(bas > haut)])
print(json.dumps(r['resume'], indent=2, ensure_ascii=False))
Le CSV de sortie conserve les identifiants de test et les colonnes x, cible, q10, q90, couverte et croisement. Il permet d’examiner les erreurs ligne par ligne sans utiliser ces lignes pour sélectionner de nouveaux réglages.
Comment lire un échec de couverture ?
Si la couverture est trop faible, examinez d’abord les populations concernées, la quantité de données, les variables disponibles et les changements de distribution. Un pourcentage global peut masquer une bande trop étroite dans une zone et trop large ailleurs. Reprenez ensuite le développement sur un lot prévu pour cela, puis utilisez un nouveau test indépendant pour le nouveau protocole.
Le script compte un intervalle croisé comme non couvert et l’exclut seulement du calcul de largeur moyenne. S’il n’existe aucun intervalle valide, la largeur est déclarée absente. Réordonner les bornes modifierait la règle évaluée ; une telle correction devrait être annoncée et évaluée comme une décision distincte.
Pour des dates, des séries ou plusieurs lignes d’une même entité, adaptez la séparation à la dépendance entre observations. Ce tirage indépendant ne valide pas une méthode de prévision temporelle. Enfin, une couverture proche de 80 % sur 600 cas n’établit ni une couverture conditionnelle uniforme ni une garantie individuelle.
Les six tests fournis vérifient les partitions, un comptage direct, les croisements, l’absence de largeur valide, la réconciliation des sous-groupes et l’absence d’influence du test sur la sélection. Pour poursuivre, consultez le projet de régression depuis un CSV et le cas de validation XGBoost.

