Regressionsmål: MAE, MSE, RMSE og R-squared
Beregn fejldimensioner på et regressionsoutput, forstå MAE's og RMSE's afhængighed af skalaen, og brug R-squared som et standardiseret mål for goodness-of-fit.
Regressionsmål: MAE, MSE, RMSE og R-squared er en gratis Machine Learning Academy-lektion på CoddyKit. Dette er lektion 3 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i Machine Learning Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Machine Learning Academy-kurset indeholder 4 lektioner i alt.
Hvorfor regression kræver andre mål
Regressionsmodeller forudsiger kontinuerte værdier — boligpriser, temperaturer og salgsvolumen. I modsætning til klassifikation, hvor en forudsigelse enten er korrekt eller forkert, er regressionsforudsigelser næsten aldrig præcis korrekte. Spørgsmålet er: hvor langt fra er forudsigelsen? Regressionsmål kvantificerer forskellen mellem forudsagte og faktiske værdier. Forskellige mål vægter fejl forskelligt: nogle straffer store fejl mere end små, nogle er robuste over for afvigere, og nogle er normaliserede, så de kan fortolkes som en andel af den forklarede varians. Valget af det rigtige mål afhænger af problemets omkostningsstruktur for fejl.
import numpy as np
y_true = np.array([100, 150, 200, 250, 300], dtype=float)
y_pred = np.array([110, 140, 210, 240, 320], dtype=float)
errors = y_pred - y_true
print('Actual: ', y_true)
print('Predicted:', y_pred)
print('Errors: ', errors) # Some positive, some negative
print('We need metrics that summarise these errors into a single number.')MAE: Gennemsnitlig absolut fejl
MAE = mean(|y_true - y_pred|). Gennemsnitlig absolut fejl beregner gennemsnittet af de absolutte forskelle mellem forudsigelser og faktiske værdier. Den er i samme enhed som målvariablen — en MAE for boligpriser på $15.000 betyder, at forudsigelserne i gennemsnit afviger med $15.000. MAE behandler alle fejl lineært: en forudsigelse, der er dobbelt så forkert, koster præcis dobbelt så meget. MAE er robust over for afvigere, fordi fejlene ikke kvadreres. Det er det anbefalede mål, når fejlfordelingen er omtrent symmetrisk, og fejl fra afvigere ikke bør dominere det samlede resultat.
import numpy as np
from sklearn.metrics import mean_absolute_error
y_true = np.array([100, 150, 200, 250, 300], dtype=float)
y_pred = np.array([110, 140, 210, 240, 320], dtype=float)
# Manual calculation
mae_manual = np.mean(np.abs(y_true - y_pred))
print('Manual MAE:', mae_manual) # |10|+|10|+|10|+|10|+|20| / 5 = 12
# Sklearn
mae = mean_absolute_error(y_true, y_pred)
print('Sklearn MAE:', mae)
print(f'Interpretation: predictions are off by {mae:.1f} units on average')MSE: Gennemsnitlig kvadreret fejl
MSE = mean((y_true - y_pred)^2). Gennemsnitlig kvadreret fejl kvadrerer hver fejl, før gennemsnittet beregnes. Det gør MSE følsom over for afvigere: en enkelt forudsigelse med en fejl på 10 bidrager med 100 til MSE, mens en forudsigelse med en fejl på 1 kun bidrager med 1 — fejl fra afvigere forstærkes kvadratisk. MSE er den naturlige tabsfunktion for lineær regression (minimering af MSE giver løsningen med almindelige mindste kvadrater). Måleenheden er målvariablen i anden potens (dollars^2 for boligpriser), hvilket gør målet mindre let at fortolke end MAE, men matematisk praktisk til optimering.
import numpy as np
from sklearn.metrics import mean_squared_error
y_true = np.array([100, 150, 200, 250, 300], dtype=float)
y_pred = np.array([110, 140, 210, 240, 320], dtype=float)
# Squaring emphasises large errors
errors = y_true - y_pred
print('Squared errors:', errors**2) # 100, 100, 100, 100, 400
mse = mean_squared_error(y_true, y_pred)
print(f'MSE: {mse}') # 160.0
print(f'Units: (target units)^2 -- less interpretable than MAE')
print(f'The large error at last sample contributes 400/5=80 to MSE alone')RMSE: Kvadratroden af den gennemsnitlige kvadrerede fejl
RMSE = sqrt(MSE). Kvadratroden af den gennemsnitlige kvadrerede fejl bringer MSE tilbage til målvariablens oprindelige enhed (dollars, ikke dollars^2) ved at tage kvadratroden. Det er det mest udbredte regressionsmål, fordi det kan fortolkes i samme enhed som målet, samtidig med at det straffer store fejl mere end små. En RMSE på $20.000 for boligpriser betyder, at den typiske fejlstørrelse er $20.000, selvom fejl fra afvigere vægtes højere end ved MAE. RMSE er altid >= MAE for de samme forudsigelser; forskellen mellem dem vokser, når der er fejl fra afvigere.
import numpy as np
from sklearn.metrics import mean_squared_error
y_true = np.array([100, 150, 200, 250, 300], dtype=float)
y_pred = np.array([110, 140, 210, 240, 320], dtype=float)
mse = mean_squared_error(y_true, y_pred)
rmse = np.sqrt(mse)
print(f'MSE: {mse:.2f} (units: target^2)')
print(f'RMSE: {rmse:.2f} (units: same as target)')
# RMSE always >= MAE
from sklearn.metrics import mean_absolute_error
mae = mean_absolute_error(y_true, y_pred)
print(f'MAE: {mae:.2f}')
print(f'MAE <= RMSE: {mae <= rmse}')MAE eller RMSE: Hvornår skal du bruge hvad
Vælg MAE, når: du forventer afvigere og ikke ønsker, at de skal dominere målet; du ønsker et mål, der let kan fortolkes som den gennemsnitlige fejl; fejl af forskellig størrelse er proportionelt lige vigtige. Vælg RMSE, når: store fejl er langt dyrere end små (f.eks. ved forudsigelse af strømbehov — det er langt dyrere at ramme 10 gange ved siden af end 1 gang); tabsfunktionen under træningen er MSE, og du ønsker, at evalueringen stemmer overens med træningen; variationen i forudsigelserne er vigtigere end den mediane fejl. I praksis skal du altid rapportere både MAE og RMSE — hvis RMSE >> MAE, dominerer fejl fra afvigere; hvis RMSE ≈ MAE, er fejlene jævnt fordelt.
import numpy as np
from sklearn.metrics import mean_absolute_error, mean_squared_error
# Two prediction sets with same MAE but different RMSE
y_true = np.array([100.0, 200.0, 300.0, 400.0, 500.0])
# Set 1: uniform errors of 10
pred1 = y_true + 10
# Set 2: mostly 0 error, one huge error of 50
pred2 = y_true.copy()
pred2[-1] += 50
pred2[0:4] += 0
for name, pred in [('Uniform errors', pred1), ('One outlier error', pred2)]:
mae = mean_absolute_error(y_true, pred)
rmse = np.sqrt(mean_squared_error(y_true, pred))
print(f'{name}: MAE={mae:.2f}, RMSE={rmse:.2f}')R-kvadreret: Determinationskoefficienten
R^2 = 1 - MSE(model) / Var(y_true). R-kvadreret måler den andel af variansen i målet, som modellen forklarer. R^2 = 1,0 betyder perfekte forudsigelser (ingen varians i residualerne). R^2 = 0,0 betyder, at modellen ikke er bedre end at forudsige gennemsnittet af y for hver observation. R^2 kan være negativ, hvis modellen er dårligere end gennemsnitsbaseline. R^2 er uafhængig af skalaen — en værdi på 0,85 betyder det samme, uanset om målet er boligpriser eller temperaturer. Det gør målet til det primære mål ved sammenligning af regressionsmodeller på tværs af forskellige problemer eller skalaer.
import numpy as np
from sklearn.metrics import r2_score
y_true = np.array([100, 150, 200, 250, 300], dtype=float)
y_pred = np.array([110, 140, 210, 240, 320], dtype=float)
y_mean = np.mean(y_true)
# Manual R^2
ss_res = np.sum((y_true - y_pred)**2) # Residual sum of squares
ss_tot = np.sum((y_true - y_mean)**2) # Total sum of squares
r2_manual = 1 - ss_res / ss_tot
print(f'SS_res (model): {ss_res}')
print(f'SS_tot (mean): {ss_tot}')
print(f'R^2 manual: {r2_manual:.4f}')
print(f'R^2 sklearn: {r2_score(y_true, y_pred):.4f}')Justeret R-kvadreret: Straf for ekstra egenskaber
Hvis du føjer flere egenskaber til en regressionsmodel, øger det altid R^2 (eller lader den være uændret) på træningsdata — også selvom egenskaberne blot er tilfældig støj. Justeret R^2 korrigerer for dette ved at straffe antallet af egenskaber: det falder, når du tilføjer en egenskab, der ikke forbedrer modellen nok til at retfærdiggøre den ekstra kompleksitet. Formel: Adj R^2 = 1 - (1 - R^2) * (n-1) / (n-p-1), hvor n = observationer og p = egenskaber. Brug justeret R^2, når du sammenligner modeller med forskelligt antal egenskaber, så du undgår at vælge unødigt komplekse modeller.
import numpy as np
def adjusted_r2(y_true, y_pred, n_features):
n = len(y_true)
r2 = r2_score(y_true, y_pred)
return 1 - (1 - r2) * (n - 1) / (n - n_features - 1)
from sklearn.metrics import r2_score
from sklearn.linear_model import LinearRegression
import numpy as np
np.random.seed(42)
n = 100
X_2 = np.random.randn(n, 2)
X_10 = np.random.randn(n, 10) # 8 noise features added
y = X_2[:, 0] * 2 + X_2[:, 1] + np.random.randn(n) * 0.5
for X, p in [(X_2, 2), (X_10, 10)]:
pred = LinearRegression().fit(X, y).predict(X)
print(f'p={p}: R^2={r2_score(y,pred):.3f}, Adj R^2={adjusted_r2(y,pred,p):.3f}')MAPE: Gennemsnitlig absolut procentvis fejl
MAPE = 100 * mean(|y_true - y_pred| / |y_true|). Gennemsnitlig absolut procentvis fejl udtrykker fejlen som en procentdel af den faktiske værdi, hvilket gør målet uafhængigt af skalaen og let at fortolke: en MAPE på 5 % betyder, at forudsigelserne i gennemsnit afviger med 5 % fra den sande værdi. Begrænsninger: MAPE er udefineret, når de faktiske værdier er nul (division med nul), og den er asymmetrisk — underforudsigelse giver en større fejl end overforudsigelse med samme beløb. Brug MAPE til prognoseopgaver (salg og efterspørgsel), hvor interessenter naturligt forstår procentvise afvigelser.
import numpy as np
def mape(y_true, y_pred):
y_true = np.array(y_true, dtype=float)
# Avoid division by zero
mask = y_true != 0
return 100 * np.mean(np.abs((y_true[mask] - np.array(y_pred)[mask]) / y_true[mask]))
y_true = [100, 200, 300, 400, 500]
y_pred = [110, 190, 315, 380, 510]
print(f'MAPE: {mape(y_true, y_pred):.2f}%')
# Asymmetry example
print(f'Over by 50: MAPE = {mape([100],[150]):.1f}%')
print(f'Under by 50: MAPE = {mape([100],[50]):.1f}%')
# Underprediction by 50% gives 50% error; overprediction by 50% also 50% (same amount, asymmetric impact)Beregning af regressionsmål med scikit-learn
Scikit-learn indeholder alle de vigtigste regressionsmål i sklearn.metrics. Når du bruger cross_val_score, skal du angive scoring='neg_mean_squared_error' (negativ, fordi højere værdier efter konvention er bedre) og ændre fortegnet på resultatet, eller bruge 'neg_root_mean_squared_error' for at få RMSE direkte. Til R^2 skal du bruge scoring='r2'. Rapportér altid flere mål: MAE for den gennemsnitlige absolutte fejl, RMSE for at vise følsomheden over for afvigere og R^2 for den forklarede varians. Det giver et komplet billede af modellens ydeevne.
from sklearn.linear_model import LinearRegression
from sklearn.datasets import fetch_california_housing
from sklearn.model_selection import cross_val_score
from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score
import numpy as np
X, y = fetch_california_housing(return_X_y=True)
for metric in ['neg_mean_absolute_error', 'neg_root_mean_squared_error', 'r2']:
scores = cross_val_score(LinearRegression(), X, y, cv=5, scoring=metric)
mean_val = scores.mean()
if 'neg' in metric:
mean_val = -mean_val
print(f'{metric.replace("neg_",""):30}: {mean_val:.4f}')Residualanalyse: Diagnosticering af modelkvalitet
Ud over opsummerende mål viser residualanalyse, om modellens antagelser er opfyldt. Afbild residualerne (y_true - y_pred) i forhold til de forudsagte værdier. En god model viser: (1) residualer, der er tilfældigt spredt omkring nul uden noget mønster (homoskedasticitet), (2) ingen sammenhæng mellem residualernes størrelse og den forudsagte værdi (ingen heteroskedasticitet). Advarselstegn: en tragtform (residualerne vokser med den forudsagte værdi) tyder på, at modellen har brug for en logaritmisk transformation; et buet mønster tyder på, at sammenhængen ikke er lineær, og at modellen er forkert specificeret. Udfør altid residualanalyse, før du implementerer en regressionsmodel.
import matplotlib.pyplot as plt
import numpy as np
from sklearn.linear_model import LinearRegression
from sklearn.datasets import fetch_california_housing
from sklearn.model_selection import train_test_split
X, y = fetch_california_housing(return_X_y=True)
X_tr, X_te, y_tr, y_te = train_test_split(X, y, random_state=42)
model = LinearRegression()
model.fit(X_tr, y_tr)
y_pred = model.predict(X_te)
residuals = y_te - y_pred
plt.figure(figsize=(8, 4))
plt.scatter(y_pred, residuals, alpha=0.3, s=10)
plt.axhline(0, color='red', linestyle='--')
plt.xlabel('Predicted Value')
plt.ylabel('Residual (Actual - Predicted)')
plt.title('Residual Plot')
plt.show()Valg af det rigtige regressionsmål
En praktisk vejledning: Brug MAE, når du vil minimere den gennemsnitlige absolutte fejl, og afvigere ikke bør fremhæves for meget — det er et robust valg til generel rapportering. Brug RMSE, når din model minimerer MSE under træningen, og du ønsker, at evalueringen skal stemme overens med træningen, eller når store fejl er særligt dyre (prognoser for efterspørgsel og energiforbrug). Brug R^2 til at sammenligne modeller på det samme datasæt eller forklare modellens kvalitet til ikke-tekniske interessenter som »procentdel af forklaret varians«. Brug MAPE til forretningsprognoser, hvor procentvise afvigelser fra de faktiske værdier er interessenternes naturlige sprog.
# Metric selection guide
def recommend_metric(has_outliers, need_interpretable_units, compare_across_scales):
if compare_across_scales:
return 'R^2 (scale-independent, 0-1 range)'
elif need_interpretable_units and has_outliers:
return 'MAE (same units as target, robust to outliers)'
elif need_interpretable_units:
return 'RMSE (same units, penalises large errors more)'
else:
return 'MSE (convenient for optimisation, same loss as linear regression)'
print(recommend_metric(True, True, False)) # MAE
print(recommend_metric(False, True, False)) # RMSE
print(recommend_metric(False, False, True)) # R^2Hurtigt tjek
Test din forståelse af begreberne inden for maskinlæring med Python fra denne lektion.
Opsummering af lektionen
I denne lektion lærte du: MAE beregner gennemsnittet af de absolutte fejl og er robust over for afvigere, RMSE kvadrerer fejlene og straffer store afvigelser hårdere, R^2 måler den andel af variansen, der forklares (0 = gennemsnitsbaseline, 1 = perfekt), og forskellen mellem MAE og RMSE viser, hvor koncentrerede afvigerfejlene er. Nu ser vi nærmere på, hvordan du vælger den rigtige metrik til dit specifikke forretningsproblem.
Lær Python med en AI-underviser — gratis
Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.
- Kurser
- 30
- Lektioner
- 120
Ofte stillede spørgsmål
Er lektionen “Regressionsmål: MAE, MSE, RMSE og R-squared” gratis?
Ja — hele teksten til “Regressionsmål: MAE, MSE, RMSE og R-squared” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af Machine Learning Academy-kurset, skal du opgradere til CoddyKit PRO. Machine Learning Academy-kurset indeholder 4 lektioner i alt.
Hvad lærer jeg i “Regressionsmål: MAE, MSE, RMSE og R-squared”?
Beregn fejldimensioner på et regressionsoutput, forstå MAE's og RMSE's afhængighed af skalaen, og brug R-squared som et standardiseret mål for goodness-of-fit. Du øver dig i Machine Learning Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.
Skal jeg have erfaring for at begynde på Machine Learning Academy?
Der kræves ingen tidligere erfaring. Machine Learning Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 3 af 4.
Hvor lang tid tager lektionen “Regressionsmål: MAE, MSE, RMSE og R-squared”?
De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.
Kan jeg skrive og køre kode i denne Machine Learning Academy-lektion?
Ja. Alle Machine Learning Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.
Alle lektioner i dette kursus
- Klassifikationsmål: Accuracy, precision, recall og F1
- ROC-kurver og AUC-ROC
- Regressionsmål: MAE, MSE, RMSE og R-squared
- Valg af det rette mål til Deres forretningsproblem