Guides

Classifieurs et régresseurs

Un modèle prédictif s'évalue comme tout autre système : un appelable renvoie une prédiction pour chaque cas, et des évaluateurs la lisent. Ce qui change, ce sont les dénominateurs. L'exactitude, le rappel et la précision sont trois taux calculés sur trois ensembles de lignes différents, et un modèle peut sembler bon sur l'un tout en échouant à la question que pose le métier.

examples/churn_model/ est le projet que cette page exécute : deux cents comptes, un modèle d'attrition déterministe, et aucun identifiant de fournisseur.

La prédiction

Le système renvoie une étiquette et, si le modèle en a un, le score qui la sous-tend :

from oloproof import system


@system(name="churn-model", version="slice-f-example")
def run(account):
    score = churn_score(account)
    return {"label": score >= 0.5, "score": round(score, 4)}

Un cas déclare la vérité sous expected :

{"expected": {"label": false}, "id": "account_000", "input": {"recent_upgrade": true, "support_contacts": 0, "tenure_months": 0}, "metadata": {"plan": "enterprise"}}

Le bloc `predictive:`

L'emplacement de la prédiction, de son score et de la vérité est déclaré une seule fois, pour le projet :

predictive:
  label_field: label
  score_field: score
  expected_field: label
  positive: true
  calibration_bins: 10
  thresholds: [0.3, 0.4, 0.5, 0.6, 0.7]

Champ	Par défaut	Signification
label_field	label	le champ de sortie qui contient l'étiquette prédite
score_field	score	le champ de sortie qui contient le score correspondant
expected_field	label	le champ sous expected qui contient la vérité
positive	true	la valeur d'étiquette comptée comme positive ; refund, 1 ou true
calibration_bins	10	le nombre de tranches de score utilisées par la table de calibration
thresholds	aucun	les seuils à balayer ; chacun est une preuve, jamais une recommandation
average	aucun	macro ou micro, pour un agrégat sur plusieurs classes

Tout évaluateur prédictif qui ne précise pas lui-même field, expected_field ou positive les prend dans ce bloc, de sorte qu'une suite n'a qu'une seule classe positive. C'est aussi ce bloc qui produit les effectifs de la matrice de confusion, la table de calibration et le balayage des seuils ; un projet qui en est dépourvu obtient les métriques et rien d'autre à côté.

Une classe positive à laquelle ne correspond l'étiquette d'aucun cas est refusée avant toute exécution, car un rappel calculé sur elle serait un taux sur rien. Le même projet avec positive: churned :

Configuration error: evaluator 'recall' counts 'churned' as the positive class, and no case's 'label' is 'churned' (labels: False, True); declare `positive:` on the evaluator or in the `predictive:` block

Les évaluateurs

evaluators:
  - {type: predictive_correct, criterion: accuracy}
  - {type: predictive_recall, criterion: recall}
  - {type: predictive_precision, criterion: precision}
  - {type: predictive_brier, criterion: brier}
  - {type: predictive_log_loss, criterion: log_loss, clip: 0.02}
  - {type: predictive_ranking, criterion: rank}
metrics:
  - {id: roc_auc, type: ranking, criterion: rank, statistic: roc_auc}
  - {id: pr_auc, type: ranking, criterion: rank, statistic: average_precision}
slices: [metadata.plan, "confidence:0.5"]
min_slice_support: 20

predictive_log_loss exige clip, car sans cela une seule erreur commise avec assurance est infinie. predictive_ranking est le critère selon lequel une métrique de classement ordonne les lignes, et il nécessite une entrée metrics: nommant la statistique : la ROC-AUC et la précision moyenne répondent à des questions différentes, et le moteur ne choisira pas à votre place.

oloproof run

│ accuracy  │ 88.5%    │ [83.2%, 92.6%]  │ 177 / 200 observed · 0 missing · 0 excluded                                │
│ recall    │ 81.2%    │ [69.5%, 90.0%]  │ 52 / 64 observed · 0 missing · 136 excluded                                │
│ precision │ 82.5%    │ [70.9%, 91.0%]  │ 52 / 63 observed · 0 missing · 137 excluded                                │
│ brier     │ 0.120    │ [0.094, 0.154]  │ mean of 200 observed · 0 missing · 0 excluded                              │
│ log_loss  │ 0.389    │ [0.323, 0.499]  │ mean of 200 observed · 0 missing · 0 excluded                              │
│ roc_auc   │ 92.3%    │ [69.3%, 100.0%] │ roc_auc over 64 positive · 136 negative · 0 missing · 0 excluded           │
│ pr_auc    │ 86.5%    │                 │ average_precision over 64 positive · 136 negative · 0 missing · 0 excluded │

Lisez la colonne excluded. Le rappel est mesuré sur les 64 comptes qui sont partis, de sorte que les 136 autres en sont exclus ; la précision, sur les 63 que le modèle a signalés. Trente-deux pour cent de ces comptes partent : un modèle qui prédit qu'aucun ne part est donc exact à 68 % et n'en trouve aucun. Un plancher sur la seule exactitude le laisserait passer, et c'est pourquoi la politique de l'exemple impose un plancher à chaque taux.

pr_auc a une estimation et pas d'intervalle. Avec deux cents lignes, son intervalle est réellement plus faible que celui de la ROC-AUC, et le moteur retient une borne qu'il ne peut pas justifier plutôt que d'en afficher une. Une règle portant sur elle donne :

pr: INSUFFICIENT_EVIDENCE (interval_unavailable)

À côté des métriques

Les effectifs de la matrice de confusion sont des effectifs, pas des taux :

│ actually positive │ 52                 │ 12                 │
│ actually negative │ 11                 │ 125                │

Une règle de publication qui en nomme un est une erreur de configuration, car un effectif n'est pas une métrique :

Configuration error: release rule 'fp' refers to unknown metric 'false_positives'

La table de calibration confronte ce que le modèle annonçait à ce qui s'est produit, par tranche de score :

│ 0.2-0.3 │ 26.7%   │ 0.0%     │ 34 rows │
│ 0.5-0.6 │ 53.4%   │ 81.0%    │ 21 rows │

Et le balayage des seuils montre ce que chaque seuil déclaré aurait mesuré :

│ 0.3     │ 57.4%     │ 96.9%  │ 62/108 predicted positive · 62/64 actual positive │
│ 0.5     │ 82.5%     │ 81.2%  │ 52/63 predicted positive · 52/64 actual positive  │
│ 0.7     │ 100.0%    │ 37.5%  │ 24/24 predicted positive · 24/64 actual positive  │

Le balayage s'intitule Thresholds (exploratory; recommends nothing). Le bon seuil dépend de ce que coûte un faux positif par rapport à un faux négatif, et ce n'est pas quelque chose que le moteur peut savoir.

Régression

Un régresseur est noté par l'erreur absolue, qui requiert l'intervalle dans lequel se trouvent ses cibles :

evaluators:
  - type: predictive_absolute_error
    criterion: days_error
    field: days
    expected_field: days
    target_range: [0, 20]

rules:
  - id: error-budget
    metric: days_error
    max: 1.5

│ days_error │ 1.02     │ [0.78, 1.88] │ mean of 120 observed · 0 missing · 0 excluded │

error-budget: INSUFFICIENT_EVIDENCE (interval_overlaps_threshold)

target_range est obligatoire et n'a pas de valeur par défaut. Une erreur absolue est une moyenne bornée, et son intervalle ne tient que dans une plage où se trouvent toutes les valeurs. Une plage plus large donne un intervalle plus large : déclarez donc la plage que les cibles peuvent réellement prendre. La règle ne peut pas trancher : l'estimation est dans le budget, et 120 commandes ne permettent pas encore de montrer que la véritable erreur moyenne l'est aussi.

Pour aller plus loin

Segments couvre les tranches confidence: et l'effectif minimal des segments.
Règles de comparaison couvre la comparaison de deux versions d'un

modèle.