Classifiers en regressors

Een predictief model wordt geëvalueerd zoals elk ander systeem: een aanroepbare functie geeft voor elke case een voorspelling terug, en evaluators lezen die. Wat er verandert, zijn de noemers. Accuracy, recall en precisie zijn drie percentages over drie verschillende verzamelingen rijen, en een model kan er op de ene goed uitzien terwijl het faalt op de vraag die het bedrijf stelt.

examples/churn_model/ is het project dat deze pagina draait: tweehonderd accounts, een deterministisch churnmodel, en geen providergegevens.

De voorspelling

Het systeem geeft een label terug en, als het model er een heeft, de score erachter:

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)}

Een case declareert de waarheid onder expected:

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

Het `predictive:`-blok

Waar de voorspelling, haar score en de waarheid staan, wordt één keer gedeclareerd, voor het project:

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]

Elke predictieve evaluator die field, expected_field of positive niet zelf vermeldt, neemt ze uit dit blok, zodat één suite één positieve klasse heeft. Het blok is ook wat de confusion-aantallen, de kalibratietabel en de drempelsweep oplevert; een project zonder het blok krijgt de metrieken en niets daarnaast.

Een positieve klasse waarmee het label van geen enkele case overeenkomt, wordt geweigerd voordat er iets draait, omdat recall daarover een percentage over niets zou zijn. Hetzelfde project met 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

De evaluators

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 vereist clip, omdat één zelfverzekerde fout anders oneindig is. predictive_ranking is het criterium waarop een rangschikkingsmetriek rijen ordent, en het heeft een metrics:-item nodig dat de statistiek noemt: ROC-AUC en average precision beantwoorden verschillende vragen, en de engine kiest er niet een voor je.

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 │

Lees de kolom excluded. Recall wordt gemeten over de 64 accounts die churnden, dus de andere 136 zijn ervan uitgesloten; precisie over de 63 die het model markeerde. Tweeëndertig procent van deze accounts churnt, dus een model dat voorspelt dat niemand churnt, is 68% accuraat en vindt niemand. Een ondergrens op alleen accuracy zou het laten slagen, en daarom legt de policy van het voorbeeld een ondergrens op elk percentage.

pr_auc heeft een schatting en geen interval. Bij tweehonderd rijen is het interval werkelijk zwakker dan dat van ROC-AUC, en de engine houdt een grens achter die hij niet kan onderbouwen in plaats van er een te tonen. Een regel daarop leest:

pr: INSUFFICIENT_EVIDENCE (interval_unavailable)

Naast de metrieken

De confusion-aantallen zijn aantallen, geen percentages:

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

Een releaseregel die er een noemt, is een configuratiefout, omdat een aantal geen metriek is:

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

De kalibratietabel zet wat het model beweerde af tegen wat er gebeurde, per scoreband:

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

En de drempelsweep laat zien wat elke gedeclareerde afkapwaarde zou hebben gemeten:

│ 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  │

De sweep heeft als titel Thresholds (exploratory; recommends nothing). Welke afkapwaarde juist is, hangt af van wat een fout-positief kost tegenover een fout-negatief, en dat kan de engine niet weten.

Regressie

Een regressor wordt gescoord op absolute fout, waarvoor het bereik nodig is waarin zijn doelwaarden liggen:

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 is verplicht, niet voorzien van een standaardwaarde. Een absolute fout is een begrensd gemiddelde, en het interval ervan geldt alleen binnen een bereik waarin elke waarde ligt. Een ruimer bereik is een breder interval, dus declareer het bereik dat de doelwaarden werkelijk kunnen aannemen. De regel kan niet beslissen: de schatting ligt binnen het budget, en 120 bestellingen kunnen nog niet aantonen dat de werkelijke gemiddelde fout dat ook doet.

Verder lezen

• Slices behandelt confidence:-banden en slice-ondersteuning.
• Vergelijkingsregels behandelt het vergelijken van twee modelversies.