Välj rätt mått för ert affärsproblem
Ni kommer att analysera tre verkliga scenarier – bedrägeridetektering, medicinsk diagnos och bostadspriser – och motivera det bästa utvärderingsmåttet för varje scenario.
Välj rätt mått för ert affärsproblem är en gratis lektion i Machine Learning Academy på CoddyKit. Detta är lektion 4 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Machine Learning Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Machine Learning Academy innehåller totalt 4 lektioner.
Mått är affärsbeslut
Valet av utvärderingsmått är inte ett rent tekniskt beslut – det återspeglar dina affärsprioriteringar och kostnadsstrukturen. En bedrägeridetektionsmodell som optimeras för accuracy presterar dåligt när det gäller att upptäcka bedrägerier i ett obalanserat dataset. En medicinsk screeningmodell som optimeras för precision kan missa alltför många sjuka patienter. Varje mått förutsätter implicit något om vilka typer av fel som är acceptabla. Att definiera rätt mått innan modellen byggs är ett av de viktigaste besluten i alla ML-projekt. Måttet styr alla efterföljande val: modellval, tröskeljustering och kriterier för driftsättning.
# The metric choice depends on error costs
# Scenario 1: Email spam filter
# FP (ham marked as spam) -> user misses important email: HIGH cost
# FN (spam reaches inbox) -> user is annoyed: LOW cost
# -> Optimise PRECISION (avoid false alarms)
# Scenario 2: Cancer screening
# FP (healthy patient flagged) -> unnecessary follow-up: LOW cost
# FN (cancer patient missed) -> delayed treatment: HIGH cost
# -> Optimise RECALL (catch all true cases)
# Scenario 3: House price prediction
# No asymmetric cost -> use RMSE or R^2
print('Define your error cost structure BEFORE choosing a metric')Scenario 1: Bedrägeridetektion
Bedrägeridetektion är det klassiska problemet med obalanserad binär klassificering. Antalet legitima transaktioner överstiger antalet bedrägerier med 1000:1 eller mer. En modell som förutsäger ”legitim” för varje transaktion uppnår 99,9 % accuracy men är helt oanvändbar. Det rätta primära måttet beror på verksamhetens begränsningar: om bedrägeriförlusterna vida överstiger kostnaderna för utredningar, optimera recall (fånga alla bedrägerier, även om det leder till många falska positiva). Om kundupplevelsen är avgörande, balansera recall och precision. Precision-Recall-kurvan och AUC-PR föredras framför ROC vid så här kraftig obalans.
import numpy as np
from sklearn.metrics import (
accuracy_score, precision_score, recall_score, f1_score,
average_precision_score, roc_auc_score
)
# Simulated fraud: 1000 transactions, 10 are fraud (1%)
y_true = np.array([0]*990 + [1]*10)
# Model A: always predict legitimate
y_dummy = np.zeros(1000, dtype=int)
print('Dummy model (always legitimate):')
print(f' Accuracy: {accuracy_score(y_true, y_dummy):.3f}') # 99% -- misleading!
print(f' Recall: {recall_score(y_true, y_dummy):.3f}') # 0.0 -- catches no fraud!
print()
print('For fraud detection: use Recall, F1, or AUC-PR')Scenario 2: Medicinsk diagnos
Inom medicinsk diagnostik är det mycket mer kostsamt att missa ett faktiskt sjukdomsfall (falskt negativt) än att genomföra ett onödigt uppföljningstest (falskt positivt). Recall (sensitivitet) bör vara det primära måttet: målet är att upptäcka så många verkliga sjukdomsfall som möjligt. En modell med hög recall och lägre precision är acceptabel – patienter med falskt positiva resultat genomgår ytterligare tester och kan friskförklaras, medan patienter med falskt negativa resultat helt missar sin diagnos. Tröskeln sätts vanligtvis mycket lågt (t.ex. 0,1 i sannolikhet) för att maximera recall, på bekostnad av många falska larm som filtreras bort genom uppföljningstester.
from sklearn.metrics import recall_score, precision_score, f1_score
import numpy as np
# Simulated diagnosis: 1000 patients, 50 have the disease
y_true = np.array([0]*950 + [1]*50)
# High-recall model: flags 200 positives, 45 are true positive
y_high_recall = np.array([0]*900 + [1]*100) # approximate
y_pred_labels = np.zeros(1000, dtype=int)
y_pred_labels[-100:] = 1 # flag last 100 (including 50 true)
TP = 50 # catches all 50 true positives
FP = 50 # but also flags 50 healthy patients
FN = 0 # misses no true positives
recall = TP / (TP + FN)
prec = TP / (TP + FP)
print(f'Medical screening model: Recall={recall:.2f}, Precision={prec:.2f}')
print('Recall 1.0 is ideal: no cancer patient missed.')Scenario 3: Rekommendationer inom e-handel
Rekommendationssystem visar användarna en rangordnad lista med objekt. Målet är att maximera rekommendationernas kvalitet. Viktiga mått är: Precision@K – hur stor andel av de K främsta rekommendationerna är relevanta? Recall@K – hur stor andel av alla relevanta objekt finns bland de K främsta? NDCG (Normalised Discounted Cumulative Gain) viktar relevansen efter position – ett relevant objekt på position 1 är värt mer än ett på position 10. Klickfrekvens och konvertering till köp är affärs-KPI:er som i slutändan är viktigare än alla ML-mått – koppla alltid modellmåtten till affärsresultat.
import numpy as np
def precision_at_k(recommended, relevant, k):
'''Of top k recommendations, fraction that are relevant'''
top_k = recommended[:k]
relevant_set = set(relevant)
hits = sum(1 for item in top_k if item in relevant_set)
return hits / k
# Example: recommend 10 items, 3 are truly relevant
recommended = ['item_A', 'item_B', 'item_C', 'item_D', 'item_E',
'item_F', 'item_G', 'item_H', 'item_I', 'item_J']
relevant = ['item_A', 'item_C', 'item_G']
for k in [3, 5, 10]:
print(f'Precision@{k}: {precision_at_k(recommended, relevant, k):.2f}')Scenario 4: Prognostisering av huspriser
För regressionsuppgifter, som att förutsäga huspriser, beror valet av mått på användningsområdet. En fastighetsplattform som visar uppskattade priser för köpare bryr sig om MAE – det typiska felet i kronor. En långivare som använder prognoser för riskbedömning bryr sig mer om att inte underskatta priserna avsevärt, vilket talar för ett riktat mått. Vid modelljämförelser ger R^2 ett normaliserat mått. Om prognoserna matas in i ett annat system (t.ex. en investeringsalgoritm) är den faktiska påverkan på avkastningen det verkliga måttet – och du måste simulera affärsprocessen för att mäta den.
from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score
import numpy as np
# Simulated house prices (in $1000s)
y_true = np.array([250, 380, 510, 420, 650, 290, 730, 480])
y_pred = np.array([265, 360, 525, 435, 620, 310, 700, 465])
mae = mean_absolute_error(y_true, y_pred)
rmse = np.sqrt(mean_squared_error(y_true, y_pred))
r2 = r2_score(y_true, y_pred)
print('House Price Model Performance:')
print(f' MAE: ${mae:.1f}k -- typical error for a buyer seeing estimates')
print(f' RMSE: ${rmse:.1f}k -- influenced by occasional large errors')
print(f' R^2: {r2:.3f} -- fraction of price variance explained')Affärs-KPI:er kontra ML-mått: överbrygga gapet
ML-mått mäter statistiska egenskaper hos prognoser, men affärs-KPI:er mäter faktiska affärsresultat. Målet är att maximera affärsvärdet genom att använda ML-mått som en approximation. Vanliga glapp är att en modell kan förbättra AUC från 0,85 till 0,88 utan att faktiskt öka intäkterna, om förbättringen gäller prognoser med lågt värde. Omvänt kan en liten förbättring av recall för bedrägerifall med högt värde spara miljoner. Koppla alltid förbättringar av ML-mått till ett uppskattat affärsvärde: ”en ökning av recall med 5 % upptäcker 50 ytterligare bedrägerifall per månad, värda X dollar”.
# Translating ML metric improvements to business value
# Fraud detection example:
new_cases_per_month = 10000 # Fraud transactions per month
avg_fraud_value = 500 # Average fraud value ($)
current_recall = 0.70 # Model catches 70% of fraud
proposed_recall = 0.80 # Improved model catches 80%
current_caught = new_cases_per_month * current_recall * avg_fraud_value
proposed_caught = new_cases_per_month * proposed_recall * avg_fraud_value
business_value = proposed_caught - current_caught
print(f'Recall improvement: {current_recall:.0%} -> {proposed_recall:.0%}')
print(f'Business value: ${business_value:,.0f}/month additional fraud prevented')Måttens överensstämmelse: träningsförlust kontra utvärderingsmått
Ett subtilt men viktigt problem är att måttet du tränar på (förlustfunktionen) kan skilja sig från måttet du utvärderar på. Logistic regression minimerar cross-entropy-förlust, inte F1-score. Om ditt utvärderingsmått är F1 kanske modellen därför inte är optimalt anpassad. Lösningar: optimera tröskeln efter träningen för att hitta den tröskel som maximerar F1 på valideringsdata, eller använd algoritmer som optimerar målmåttet direkt (t.ex. XGBoost med anpassade målfunktioner). För regression minimerar LinearRegression MSE – om du bryr dig om MAE kan du överväga HuberRegressor eller förlustfunktioner som är särskilt utformade för MAE.
from sklearn.metrics import f1_score
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
import numpy as np
X, y = load_breast_cancer(return_X_y=True)
X_tr, X_te, y_tr, y_te = train_test_split(X, y, random_state=42)
clf = LogisticRegression(max_iter=10000)
clf.fit(X_tr, y_tr)
proba = clf.predict_proba(X_te)[:, 1]
# Find threshold that maximises F1
best_f1, best_thresh = 0, 0.5
for thresh in np.linspace(0.1, 0.9, 81):
pred = (proba >= thresh).astype(int)
f1 = f1_score(y_te, pred, zero_division=0)
if f1 > best_f1:
best_f1, best_thresh = f1, thresh
print(f'Default (0.5) F1: {f1_score(y_te, (proba>=0.5).astype(int)):.4f}')
print(f'Optimised F1: {best_f1:.4f} at threshold {best_thresh:.2f}')Rapportering med flera mått: hela bilden
I ML-projekt i produktion ska du aldrig rapportera ett enda mått – tillhandahåll en måttdashboard som ger en komplett bild. För klassificering: accuracy (för helhetsbilden), precision och recall (för att förstå feltyper), F1 (som balanserad sammanfattning) och AUC (oberoende av tröskel). För regression: MAE, RMSE och R^2 tillsammans. Ta med jämförelser med en baslinje: en DummyClassifier eller DummyRegressor som använder den enklaste strategin (förutsäg alltid den vanligaste klassen eller medelvärdet). Varje verklig modell måste överträffa baslinjen avsevärt för alla relevanta mått för att anses användbar.
from sklearn.metrics import (
accuracy_score, precision_score, recall_score, f1_score, roc_auc_score
)
from sklearn.dummy import DummyClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
X, y = load_breast_cancer(return_X_y=True)
X_tr, X_te, y_tr, y_te = train_test_split(X, y, random_state=42)
X_tr_s = StandardScaler().fit_transform(X_tr)
X_te_s = StandardScaler().fit(X_tr).transform(X_te)
for name, clf in [('Dummy', DummyClassifier(strategy='most_frequent')),
('LogReg', LogisticRegression(max_iter=1000))]:
clf.fit(X_tr_s, y_tr)
pred = clf.predict(X_te_s)
prob = clf.predict_proba(X_te_s)[:, 1]
print(f'\n{name}:')
print(f' Accuracy={accuracy_score(y_te,pred):.3f}, '
f'Precision={precision_score(y_te,pred):.3f}, '
f'Recall={recall_score(y_te,pred):.3f}, '
f'F1={f1_score(y_te,pred):.3f}, '
f'AUC={roc_auc_score(y_te,prob):.3f}')Kalibrering: Betyder sannolikheterna det de säger?
En modell kan ha bra AUC men dålig kalibrering – de förutsagda sannolikheterna motsvarar inte de faktiska frekvenserna. En välkalibrerad modell som anger 80 % sannolikhet bör ha rätt 80 % av gångerna. Kalibrering är viktigt när: själva sannolikheten används (inte bara klassetiketten), i riskpoängsystem och i flerstegspipelines där en modells utdata är en annan modells indata. Använd CalibrationDisplay för att rita upp intervall med förutsagda sannolikheter mot den faktiska andelen positiva. Random forests och boostingträd är ofta dåligt kalibrerade, medan logistisk regression och Naive Bayes brukar vara bättre. Kalibrering i efterhand med CalibratedClassifierCV kan åtgärda detta.
from sklearn.calibration import CalibrationDisplay
from sklearn.ensemble import RandomForestClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
import matplotlib.pyplot as plt
X, y = load_breast_cancer(return_X_y=True)
X_tr, X_te, y_tr, y_te = train_test_split(X, y, random_state=42)
fig, ax = plt.subplots(figsize=(8, 6))
for name, clf in [('LogReg', LogisticRegression(max_iter=1000)),
('RandomForest', RandomForestClassifier(n_estimators=100))]:
clf.fit(X_tr, y_tr)
CalibrationDisplay.from_estimator(clf, X_te, y_te, ax=ax, name=name, n_bins=10)
ax.set_title('Calibration Curves')
plt.show()Ett beslutsramverk för val av mått
Här är ett komplett beslutsramverk: Steg 1: Är detta klassificering eller regression? Steg 2: För klassificering – är klasserna balanserade? Om inte, använd AUC/F1/PR-kurvan. Steg 3: Vilken är den relativa kostnaden för FP jämfört med FN? Hög FP-kostnad → precision; hög FN-kostnad → recall. Steg 4: För regression – beror felen på skalan? Använd i så fall RMSE/MAE; använd R^2 om du jämför olika problem. Steg 5: Behöver sannolikheterna vara korrekta? Lägg till en kalibreringsutvärdering. Steg 6: Definiera hur måttet översätts till en affärs-KPI. Dokumentera detta ramverk i varje projekts model card.
def select_metric(task, balanced, fp_cost_high, fn_cost_high, need_proba_cal):
if task == 'regression':
return 'MAE + RMSE + R^2 (report all three)'
# Classification:
if not balanced:
if fn_cost_high and fp_cost_high:
return 'F1 + AUC-PR (balance precision and recall)'
elif fn_cost_high:
return 'Recall + AUC-PR (minimise missed positives)'
elif fp_cost_high:
return 'Precision + AUC-ROC (minimise false alarms)'
else:
return 'Accuracy + F1 + AUC-ROC'
return 'AUC-ROC + F1'
print(select_metric('classification', False, False, True, False)) # Recall
print(select_metric('classification', True, True, True, False)) # Accuracy+F1
print(select_metric('regression', True, False, False, False)) # MAE+RMSE+R^2Dokumentera valet av mått
Varje driftsatt modell bör ha ett model card som dokumenterar det valda måttet, motiveringen, baslinjens resultat, den driftsatta modellens resultat och hur måttet översätts till en affärs-KPI. Detta skapar ansvarstagande: när intressenter inom verksamheten frågar ”är modellen tillräckligt bra?” kan du svara: ”vår bedrägerimodell uppnår 82 % recall för transaktioner över 1 000 dollar, med en andel falskt positiva på 3 %, och förhindrar månatliga förluster på 2,3 miljoner dollar jämfört med vårt regelbaserade system”. Det är skillnaden mellan ett akademiskt experiment och ett ML-system i produktion. Dokumentation av mått är lika viktig som själva modellen.
# Minimal model card template
model_card = {
'model_name': 'Fraud Detector v2.1',
'task': 'Binary classification (fraud / legitimate)',
'primary_metric': 'Recall at FPR=0.03',
'metric_rationale': 'Missing fraud (FN) costs $500 avg; false alarm (FP) costs $5 investigation',
'baseline': {'model': 'DummyClassifier(most_frequent)', 'recall': 0.0, 'fpr': 0.0},
'deployed_model': {'algorithm': 'XGBoost', 'recall': 0.82, 'fpr': 0.03},
'business_kpi': '$2.3M/month fraud prevented vs rule-based system',
'evaluation_date': '2026-06-20',
'training_data': 'Transactions 2024-01 to 2025-12, 5M samples'
}
for key, value in model_card.items():
print(f'{key}: {value}')Snabbkontroll
Testa dina kunskaper om begreppen inom Machine Learning with Python från den här lektionen.
Sammanfattning av lektionen
I den här lektionen har du lärt dig att valet av mått är ett affärsbeslut som styrs av de relativa kostnaderna för falskt positiva och falskt negativa resultat, hur tre verkliga scenarier – bedrägeridetektion, medicinsk diagnos och rekommendationssystem – kräver olika primära mått, samt vikten av att dokumentera valet av mått och koppla det till affärs-KPI:er. Därmed är kursen Model Evaluation Metrics slutförd – härnäst börjar vi MIDLEVEL-spåret med Random Forest and Ensemble Methods.
Lär dig Python med en AI-lärare – gratis
Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.
- Kurser
- 30
- Lektioner
- 120
Vanliga frågor
Är lektionen ”Välj rätt mått för ert affärsproblem” gratis?
Ja – hela texten till ”Välj rätt mått för ert affärsproblem” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Machine Learning Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i Machine Learning Academy innehåller totalt 4 lektioner.
Vad lär jag mig i ”Välj rätt mått för ert affärsproblem”?
Ni kommer att analysera tre verkliga scenarier – bedrägeridetektering, medicinsk diagnos och bostadspriser – och motivera det bästa utvärderingsmåttet för varje scenario. Ni övar på Machine Learning Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.
Behöver jag någon erfarenhet för att börja lära mig Machine Learning Academy?
Du behöver inga förkunskaper. Utbildningen i Machine Learning Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 4 av 4.
Hur lång tid tar lektionen ”Välj rätt mått för ert affärsproblem”?
De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.
Kan jag skriva och köra kod i den här Machine Learning Academy-lektionen?
Ja. Varje Machine Learning Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.
Alla lektioner i den här kursen
- Klassificeringsmått: accuracy, precision, recall och F1
- ROC-kurvor och AUC-ROC
- Regressionsmått: MAE, MSE, RMSE och R-kvadrat
- Välj rätt mått för ert affärsproblem