Machine Learning Academy · Lezione

Metriche di regressione: MAE, MSE, RMSE e R-squared

Calcolerà le metriche d'errore sull'output di una regressione, comprenderà la dipendenza di MAE/RMSE dalla scala e utilizzerà R-squared come misura standardizzata della bontà dell'adattamento.

Lezione 3 di 413 passaggi

Metriche di regressione: MAE, MSE, RMSE e R-squared è una lezione Machine Learning Academy gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Machine Learning Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Machine Learning Academy include 4 lezioni in totale.

Perché la regressione richiede metriche diverse

I modelli di regressione predicono valori continui: prezzi delle abitazioni, temperature, volumi di vendita. A differenza della classificazione, in cui una previsione è corretta o errata, le previsioni di regressione sono quasi mai esattamente corrette. La domanda è: quanto si discosta la previsione dal valore reale? Le metriche di regressione quantificano la differenza tra i valori previsti e quelli effettivi. Metriche diverse assegnano pesi diversi agli errori: alcune penalizzano maggiormente gli errori grandi rispetto a quelli piccoli, alcune sono robuste agli outlier e alcune sono normalizzate per essere interpretabili come frazione della varianza spiegata. La scelta della metrica corretta dipende dalla struttura dei costi degli errori del problema.

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: errore assoluto medio

MAE = mean(|y_true - y_pred|). L'errore assoluto medio calcola la media delle differenze assolute tra le previsioni e i valori effettivi. È espresso nella stessa unità della variabile target: un MAE di 15.000 $ per il prezzo di un'abitazione significa che, in media, le previsioni si discostano di 15.000 $. Il MAE tratta tutti gli errori in modo lineare: una previsione due volte più errata ha esattamente il doppio del costo. Il MAE è robusto agli outlier perché non eleva al quadrato gli errori. È la metrica consigliata quando la distribuzione degli errori è approssimativamente simmetrica e non si desidera che gli errori anomali dominino l'aggregazione.

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: errore quadratico medio

MSE = mean((y_true - y_pred)^2). L'errore quadratico medio eleva al quadrato ogni errore prima di calcolarne la media. Questo rende l'MSE sensibile agli outlier: una singola previsione con errore pari a 10 contribuisce per 100 all'MSE, mentre una previsione con errore pari a 1 contribuisce solo per 1; gli errori anomali vengono quindi amplificati quadraticamente. L'MSE è la funzione di perdita naturale per la regressione lineare (minimizzare l'MSE produce la soluzione dei minimi quadrati ordinari). La sua unità di misura è il quadrato di quella della variabile target (dollari^2 per i prezzi delle abitazioni), il che la rende meno interpretabile del MAE, ma matematicamente conveniente per l'ottimizzazione.

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: radice dell'errore quadratico medio

RMSE = sqrt(MSE). La radice dell'errore quadratico medio riporta l'MSE alle unità originali della variabile target (dollari, non dollari^2) calcolandone la radice quadrata. È la metrica di regressione più utilizzata perché è interpretabile nella stessa unità della variabile target, pur penalizzando gli errori grandi più di quelli piccoli. Un RMSE di 20.000 $ per i prezzi delle abitazioni significa che l'entità tipica dell'errore è di 20.000 $, sebbene gli errori anomali abbiano un peso maggiore rispetto al MAE. RMSE è sempre >= MAE per le stesse previsioni; la differenza tra i due aumenta quando sono presenti errori anomali.

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 e RMSE: quale utilizzare e quando

Scelga il MAE quando: si prevedono outlier e non si desidera che dominino la metrica; si vuole una metrica facilmente interpretabile come errore medio; gli errori di entità diversa sono proporzionalmente importanti allo stesso modo. Scelga l'RMSE quando: gli errori grandi sono molto più costosi di quelli piccoli (ad esempio, nella previsione della domanda di energia, un errore di 10 volte è molto più costoso di un errore di 1 volta); la funzione di perdita utilizzata durante l'addestramento è l'MSE e si desidera che la valutazione sia coerente con l'addestramento; la varianza delle previsioni è più importante dell'errore mediano. In pratica, riporti sempre sia il MAE sia l'RMSE: se RMSE >> MAE, dominano gli errori anomali; se RMSE ≈ MAE, gli errori sono distribuiti in modo uniforme.

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-quadrato: coefficiente di determinazione

R^2 = 1 - MSE(model) / Var(y_true). R-squared misura la frazione della varianza della variabile target spiegata dal modello. R^2 = 1,0 indica previsioni perfette (varianza residua nulla). R^2 = 0,0 indica che il modello non è migliore della previsione della media di y per ogni campione. R^2 può essere negativo se il modello è peggiore del valore di riferimento basato sulla media. R^2 è indipendente dalla scala: un valore di 0,85 ha lo stesso significato sia per i prezzi delle abitazioni sia per le temperature. Questo lo rende la metrica principale per confrontare modelli di regressione relativi a problemi o scale diverse.

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

R-quadrato corretto: penalizzare le variabili aggiuntive

L'aggiunta di più variabili a un modello di regressione aumenta sempre R^2 (o lo lascia invariato) sui dati di addestramento, anche quando tali variabili sono rumore casuale. R^2 corretto tiene conto di questo penalizzando il numero di variabili: diminuisce quando si aggiunge una variabile che non migliora il modello abbastanza da giustificare la complessità aggiuntiva. Formula: Adj R^2 = 1 - (1 - R^2) * (n-1) / (n-p-1) dove n = campioni, p = variabili. Utilizzi R^2 corretto quando confronta modelli con numeri diversi di variabili, per evitare di selezionare modelli eccessivamente complessi.

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: errore percentuale assoluto medio

MAPE = 100 * mean(|y_true - y_pred| / |y_true|). L'errore percentuale assoluto medio esprime l'errore come percentuale del valore effettivo, rendendolo indipendente dalla scala e facilmente interpretabile: un MAPE del 5% significa che, in media, le previsioni si discostano del 5% dal valore reale. Limitazioni: il MAPE non è definito quando i valori effettivi sono zero (divisione per zero) ed è asimmetrico: una sottostima produce un errore maggiore rispetto a una sovrastima dello stesso importo. Utilizzi il MAPE per attività di previsione (vendite, domanda) in cui gli stakeholder comprendono naturalmente le variazioni percentuali.

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)

Calcolo delle metriche di regressione con scikit-learn

Scikit-learn fornisce tutte le principali metriche di regressione nel modulo sklearn.metrics. Quando utilizza cross_val_score, passi scoring='neg_mean_squared_error' (negativo perché, per convenzione, un valore più alto è migliore) e ne neghi il risultato, oppure utilizzi 'neg_root_mean_squared_error' per ottenere direttamente l'RMSE. Per R^2, utilizzi scoring='r2'. Riporti sempre più metriche: MAE per l'errore assoluto medio, RMSE per mostrare la sensibilità agli outlier e R^2 per la varianza spiegata. In questo modo ottiene un quadro completo delle prestazioni del modello.

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

Analisi dei residui: diagnosi della qualità del modello

Oltre alle metriche riassuntive, l'analisi dei residui rivela se le ipotesi del modello sono rispettate. Tracci i residui (y_true - y_pred) rispetto ai valori previsti. Un buon modello mostra: (1) residui dispersi casualmente intorno allo zero, senza alcun andamento (omoschedasticità); (2) nessuna relazione tra l'ampiezza dei residui e il valore previsto (assenza di eteroschedasticità). Segnali di allarme: una forma a imbuto (i residui aumentano con il valore previsto) suggerisce che il modello necessita di una trasformazione logaritmica; un andamento curvo suggerisce che la relazione non è lineare e che il modello è mal specificato. Esegua sempre un'analisi dei residui prima di distribuire qualsiasi modello di regressione.

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

Scelta della metrica di regressione corretta

Una guida pratica: utilizzi il MAE quando desidera minimizzare l'errore assoluto medio e non vuole dare eccessiva importanza agli outlier: è una scelta robusta per i report generali. Utilizzi l'RMSE quando il modello minimizza l'MSE durante l'addestramento e desidera che la valutazione sia coerente, oppure quando gli errori grandi sono particolarmente costosi (previsione della domanda, previsione del consumo energetico). Utilizzi R^2 per confrontare modelli sullo stesso dataset o per spiegare la qualità del modello agli stakeholder non tecnici come «percentuale di varianza spiegata». Utilizzi il MAPE per le previsioni aziendali, quando le variazioni percentuali rispetto ai valori effettivi costituiscono il linguaggio naturale degli stakeholder.

# 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^2

Verifica rapida

Verifichi la Sua comprensione dei concetti di Machine Learning con Python presentati in questa lezione.

Riepilogo della lezione

In questa lezione ha imparato che: MAE calcola la media degli errori assoluti ed è robusto rispetto agli outlier, RMSE eleva al quadrato gli errori e penalizza maggiormente le deviazioni ampie, R^2 misura la frazione di varianza spiegata (0 = baseline della media, 1 = perfetto) e la differenza tra MAE e RMSE rivela la concentrazione degli errori dovuti agli outlier. Ora esamineremo come scegliere la metrica più adatta al Suo specifico problema aziendale.

Gratis per iniziare

Impara Python con un tutor IA — gratis

Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.

Corsi
30
Lezioni
120

Domande Frequenti

La lezione «Metriche di regressione: MAE, MSE, RMSE e R-squared» è gratuita?

Sì — il testo completo di «Metriche di regressione: MAE, MSE, RMSE e R-squared» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Machine Learning Academy, passa a CoddyKit PRO. Il corso Machine Learning Academy include 4 lezioni in totale.

Cosa imparerò in «Metriche di regressione: MAE, MSE, RMSE e R-squared»?

Calcolerà le metriche d'errore sull'output di una regressione, comprenderà la dipendenza di MAE/RMSE dalla scala e utilizzerà R-squared come misura standardizzata della bontà dell'adattamento. Eserciti Machine Learning Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Machine Learning Academy?

Non è richiesta alcuna esperienza precedente. Machine Learning Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.

Quanto tempo richiede la lezione «Metriche di regressione: MAE, MSE, RMSE e R-squared»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Machine Learning Academy?

Sì. Ogni lezione Machine Learning Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Metriche di classificazione: accuracy, precision, recall e F1
  2. Curve ROC e AUC-ROC
  3. Metriche di regressione: MAE, MSE, RMSE e R-squared
  4. Scegliere la metrica giusta per il problema aziendale
← Torna a Machine Learning Academy