회귀 모델 평가 지표: MSE, MAE, R², MAPE 언제 어떤 걸 쓸까

MAE = (1/n) * sum(|yi - ŷi|)

import numpy as np

y_true = np.array([3.0, 5.0, 2.5, 7.0, 4.5])
y_pred = np.array([2.8, 5.3, 2.0, 6.5, 5.0])

# 수동 계산
residuals = y_true - y_pred
mae = np.mean(np.abs(residuals))
print(f"잔차:  {residuals}")
print(f"MAE:   {mae:.4f}")

잔차:  [ 0.2 -0.3  0.5  0.5 -0.5]
MAE:   0.4000

MSE = (1/n) * sum((yi - ŷi)²)

mse = np.mean(residuals**2)
print(f"MSE:   {mse:.4f}")

MSE:   0.1760

RMSE = sqrt(MSE) = sqrt((1/n) * sum((yi - ŷi)²))

rmse = np.sqrt(mse)
print(f"RMSE:  {rmse:.4f}")

RMSE:  0.4195

# 균일한 오차
y_uniform = np.array([1.0, 1.0, 1.0, 1.0, 1.0])
y_pred_u  = np.array([1.2, 0.8, 1.1, 0.9, 1.2])
mae_u  = np.mean(np.abs(y_uniform - y_pred_u))
rmse_u = np.sqrt(np.mean((y_uniform - y_pred_u)**2))
print(f"균일한 오차  → MAE: {mae_u:.4f}, RMSE: {rmse_u:.4f}, 비율: {rmse_u/mae_u:.2f}")

# 이상치 포함
y_outlier = np.array([1.0, 1.0, 1.0, 1.0, 1.0])
y_pred_o  = np.array([1.1, 0.9, 1.1, 0.9, 4.0])
mae_o  = np.mean(np.abs(y_outlier - y_pred_o))
rmse_o = np.sqrt(np.mean((y_outlier - y_pred_o)**2))
print(f"이상치 포함  → MAE: {mae_o:.4f}, RMSE: {rmse_o:.4f}, 비율: {rmse_o/mae_o:.2f}")

균일한 오차  → MAE: 0.1600, RMSE: 0.1673, 비율: 1.05
이상치 포함  → MAE: 0.6800, RMSE: 1.3446, 비율: 1.98

from sklearn.metrics import mean_absolute_error, mean_squared_error

y_true = np.array([100, 150, 200, 250, 300])
y_pred = np.array([110, 140, 190, 245, 350])

mae  = mean_absolute_error(y_true, y_pred)
mse  = mean_squared_error(y_true, y_pred)
rmse = np.sqrt(mse)

print(f"MAE:  {mae:.2f}")
print(f"MSE:  {mse:.2f}")
print(f"RMSE: {rmse:.2f}")

MAE:  17.00
MSE:  565.00
RMSE: 23.77

R² = 1 - (SS_res / SS_tot)

SS_res = sum((yi - ŷi)²)        ← 모델의 잔차 제곱합
SS_tot = sum((yi - ȳ)²)         ← 총 변동 (타겟의 분산 * n)

from sklearn.metrics import r2_score

y_true = np.array([3, 5, 2.5, 7, 4.5])
y_pred = np.array([2.8, 5.3, 2.0, 6.5, 5.0])

r2 = r2_score(y_true, y_pred)

# 수동 검증
ss_res = np.sum((y_true - y_pred)**2)
ss_tot = np.sum((y_true - np.mean(y_true))**2)
r2_manual = 1 - ss_res / ss_tot

print(f"R² (sklearn):  {r2:.4f}")
print(f"R² (수동):     {r2_manual:.4f}")
print(f"SS_res:        {ss_res:.4f}")
print(f"SS_tot:        {ss_tot:.4f}")

R² (sklearn):  0.9307
R² (수동):     0.9307
SS_res:        0.8800
SS_tot:        12.7000

Adjusted R² = 1 - ((1 - R²) * (n - 1)) / (n - p - 1)

n = 샘플 수
p = 특성 수

from sklearn.linear_model import LinearRegression
from sklearn.datasets import make_regression

np.random.seed(42)

# 유용한 특성 3개 + 노이즈 특성 추가
X, y = make_regression(n_samples=100, n_features=3, noise=10, random_state=42)
noise_features = np.random.randn(100, 7)  # 쓸모없는 특성 7개

def adjusted_r2(r2, n, p):
    return 1 - ((1 - r2) * (n - 1)) / (n - p - 1)

# 특성을 하나씩 추가하면서 비교
print(f"{'특성 수':>6} | {'R²':>8} | {'Adj R²':>8}")
print("-" * 30)

for k in range(1, 11):
    if k <= 3:
        X_k = X[:, :k]
    else:
        X_k = np.hstack([X, noise_features[:, :k-3]])

    model = LinearRegression()
    model.fit(X_k, y)
    r2 = r2_score(y, model.predict(X_k))
    adj_r2 = adjusted_r2(r2, len(y), k)
    print(f"{k:>6} | {r2:>8.4f} | {adj_r2:>8.4f}")

특성 수 |       R² |   Adj R²
------------------------------
     1 |   0.5842 |   0.5800
     2 |   0.7813 |   0.7768
     3 |   0.9507 |   0.9491
     4 |   0.9508 |   0.9487
     5 |   0.9510 |   0.9484
     6 |   0.9511 |   0.9479
     7 |   0.9513 |   0.9476
     8 |   0.9515 |   0.9473
     9 |   0.9516 |   0.9468
    10 |   0.9518 |   0.9464

MAPE = (100/n) * sum(|yi - ŷi| / |yi|)

def mape(y_true, y_pred):
    return np.mean(np.abs((y_true - y_pred) / y_true)) * 100

y_true = np.array([100, 200, 300, 400, 500])
y_pred = np.array([110, 190, 310, 380, 520])

print(f"MAPE: {mape(y_true, y_pred):.2f}%")
print(f"MAE:  {mean_absolute_error(y_true, y_pred):.2f}")

MAPE: 5.47%
MAE:  14.00

# MAPE 실패 사례
y_true_zero = np.array([0.0, 100, 200, 300, 400])
y_pred_zero = np.array([5.0, 110, 190, 310, 380])

# 직접 계산하면 문제가 보인다
for yt, yp in zip(y_true_zero, y_pred_zero):
    if yt != 0:
        pct = abs(yt - yp) / abs(yt) * 100
        print(f"실제: {yt:6.1f}, 예측: {yp:6.1f}, 오차율: {pct:.1f}%")
    else:
        print(f"실제: {yt:6.1f}, 예측: {yp:6.1f}, 오차율: ∞ (0으로 나누기!)")

실제:    0.0, 예측:    5.0, 오차율: ∞ (0으로 나누기!)
실제:  100.0, 예측:  110.0, 오차율: 10.0%
실제:  200.0, 예측:  190.0, 오차율: 5.0%
실제:  300.0, 예측:  310.0, 오차율: 3.3%
실제:  400.0, 예측:  380.0, 오차율: 5.0%

sMAPE = (100/n) * sum(|yi - ŷi| / ((|yi| + |ŷi|) / 2))

MSLE  = (1/n) * sum((log(1+yi) - log(1+ŷi))²)
RMSLE = sqrt(MSLE)

from sklearn.metrics import mean_squared_log_error

# 집값 예측 시나리오 (단위: 만 원)
y_true = np.array([5000, 10000, 50000, 100000])
y_pred = np.array([5500, 11000, 55000, 110000])

# 절대 오차는 비싼 집일수록 크다
print("절대 오차와 로그 오차 비교:")
print(f"{'실제':>8} | {'예측':>8} | {'절대오차':>8} | {'오차율':>6} | {'로그오차':>8}")
for yt, yp in zip(y_true, y_pred):
    abs_err = abs(yt - yp)
    pct_err = abs_err / yt * 100
    log_err = abs(np.log1p(yt) - np.log1p(yp))
    print(f"{yt:>8} | {yp:>8} | {abs_err:>8} | {pct_err:>5.1f}% | {log_err:>8.4f}")

print(f"\nRMSE:  {np.sqrt(mean_squared_error(y_true, y_pred)):.2f}")
print(f"RMSLE: {np.sqrt(mean_squared_log_error(y_true, y_pred)):.4f}")

절대 오차와 로그 오차 비교:
    실제 |     예측 |   절대오차 |  오차율 |   로그오차
    5000 |     5500 |      500 |  10.0% |   0.0953
   10000 |    11000 |     1000 |  10.0% |   0.0953
   50000 |    55000 |     5000 |  10.0% |   0.0953
  100000 |   110000 |    10000 |  10.0% |   0.0953

RMSE:  5700.88
RMSLE: 0.0953

# 같은 절대 오차라도 방향에 따라 RMSLE가 다르다
y_true_dir = np.array([100, 100])
y_over     = np.array([150, 100])   # 과대예측 +50
y_under    = np.array([50,  100])   # 과소예측 -50

msle_over  = mean_squared_log_error(y_true_dir, y_over)
msle_under = mean_squared_log_error(y_true_dir, y_under)

print(f"과대예측 (+50) MSLE: {msle_over:.4f}")
print(f"과소예측 (-50) MSLE: {msle_under:.4f}")

과대예측 (+50) MSLE: 0.0809
과소예측 (-50) MSLE: 0.2334

import numpy as np
from sklearn.datasets import fetch_california_housing
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LinearRegression, Ridge, Lasso
from sklearn.ensemble import RandomForestRegressor, GradientBoostingRegressor
from sklearn.metrics import (
    mean_absolute_error,
    mean_squared_error,
    r2_score,
    mean_absolute_percentage_error,
    mean_squared_log_error,
)

# 데이터 로드
data = fetch_california_housing()
X, y = data.data, data.target

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# 스케일링 (선형 모델용)
scaler = StandardScaler()
X_train_s = scaler.fit_transform(X_train)
X_test_s  = scaler.transform(X_test)

# 모델 정의
models = {
    "Linear Regression": LinearRegression(),
    "Ridge (alpha=1)":   Ridge(alpha=1.0),
    "Lasso (alpha=0.01)": Lasso(alpha=0.01),
    "Random Forest":     RandomForestRegressor(n_estimators=100, random_state=42),
    "Gradient Boosting": GradientBoostingRegressor(n_estimators=200, random_state=42),
}

# 평가
print(f"{'모델':<22} | {'MAE':>6} | {'RMSE':>6} | {'R²':>6} | {'MAPE':>7} | {'RMSLE':>7}")
print("-" * 72)

for name, model in models.items():
    # 트리 모델은 스케일링 불필요
    if "Forest" in name or "Boosting" in name:
        model.fit(X_train, y_train)
        y_pred = model.predict(X_test)
    else:
        model.fit(X_train_s, y_train)
        y_pred = model.predict(X_test_s)

    mae   = mean_absolute_error(y_test, y_pred)
    rmse  = np.sqrt(mean_squared_error(y_test, y_pred))
    r2    = r2_score(y_test, y_pred)
    mape_val = mean_absolute_percentage_error(y_test, y_pred) * 100

    # RMSLE는 음수 예측이 있으면 계산 불가 → 클리핑
    y_pred_clip = np.maximum(y_pred, 0)
    try:
        rmsle = np.sqrt(mean_squared_log_error(y_test, y_pred_clip))
    except ValueError:
        rmsle = float('nan')

    print(f"{name:<22} | {mae:>6.4f} | {rmse:>6.4f} | {r2:>6.4f} | {mape_val:>6.2f}% | {rmsle:>7.4f}")

모델                   |    MAE |   RMSE |     R² |    MAPE |   RMSLE
------------------------------------------------------------------------
Linear Regression      | 0.5332 | 0.7456 | 0.5758 | 32.99% |  0.3983
Ridge (alpha=1)        | 0.5332 | 0.7456 | 0.5758 | 32.98% |  0.3982
Lasso (alpha=0.01)     | 0.5376 | 0.7496 | 0.5712 | 33.47% |  0.4008
Random Forest          | 0.3272 | 0.5035 | 0.8067 | 16.73% |  0.2462
Gradient Boosting      | 0.3709 | 0.5545 | 0.7653 | 19.79% |  0.2756

# ❌ R²가 높다고 좋은 모델이 아닐 수 있다
# 특성 수가 많으면 R²는 자동으로 올라간다
print("특성 3개 모델:  R² = 0.9491 (Adj R² = 0.9491)")
print("특성 10개 모델: R² = 0.9518 (Adj R² = 0.9464)")
print()
print("R²만 보면 10개 특성이 낫지만,")
print("Adjusted R²를 보면 3개 특성이 더 낫다.")