[ML] 지도학습(회귀)

학습 내용

• 지도학습 방법중 회귀문제에서 활용할 수 있는 방법들을 정리하였다.

 

지도학습(회귀)

선형 회귀

• 선형회귀
  • 단순 선형 회귀: 독립변수(피처)가 1개
  • 다중 선형 회귀: 독립변수(피처)가 2개 이상
• 비용함수 (Cost function)
  • 손실함수(Loss function), 목적함수 (objective function)
  • 오차(error)를 계산 (실제 값과 예측 값 차이)
  • 평균 제곱 오차를 최소화하는 파라미터를 찾음
• 경사하강법 (Gradient Descent)
  • 경사하강법을 활용해 최소 에러 값을 찾음
  • 비용함수의 기울기 절대값이 가장 작은 지점을 찾아서 오차가 작은 모델을 만듭니다.

# 라이브러리 불러오기
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error

# 데이터 생성
from sklearn.datasets import load_diabetes # 당뇨병 환자 데이터

def make_dataset():
    dataset = load_diabetes()
    df = pd.DataFrame(dataset.data, columns=dataset.feature_names)
    df['target'] = dataset.target
    X_train, X_test, y_train, y_test = train_test_split(
        df.drop('target', axis=1), df['target'], test_size=0.2, random_state=1004)
    return X_train, X_test, y_train, y_test

X_train, X_test, y_train, y_test = make_dataset()
X_train.shape, X_test.shape, y_train.shape, y_test.shape

# 선형 회귀
from sklearn.linear_model import LinearRegression
model = LinearRegression()
model.fit(X_train, y_train)
pred = model.predict(X_test)
mean_squared_error(y_test, pred)

 

릿지 회귀

• 회귀를 위한 선형 모델
• 규제(regularization) 적용
  • 오버피팅 되지 않도록 함
  • 규제 방식 : L2 규제
  • 파라미터(alpha) 값을 활용해 조절
  • alpha 값이 커질 수록 회귀 계수 값을 작게 만듦
    • 예) Y = W1X1 + W2X2 +W3X3 +...+ WnXn 회귀계수: W, 피처(변수) : X
    • $J(\theta) = MSE (\theta) + \alpha {1 \over 2} \sum_{i=1}^n {\theta_{i}}^2$

# 릿지 회귀
from sklearn.linear_model import Ridge
model = Ridge(alpha=1)
model.fit(X_train, y_train)
pred = model.predict(X_test)
mean_squared_error(y_test, pred)

# 회귀 계수
coef = pd.DataFrame(data=model.coef_, index=X_train.columns, columns=['alpha1'])
coef

# alpha는 학습 데이터 적합 정도와 회귀 계수 값을 크기 제어를 수행하는 튜닝 파라미터


# 릿지 회귀 (alpha=10)
model = Ridge(alpha=10)
model.fit(X_train, y_train)
pred = model.predict(X_test)
mean_squared_error(y_test, pred)	# 오차가 커질수록 나쁜 성능


# 회귀 계수 (alpha 10)
coef['alpha10'] = model.coef_
coef


# 릿지 회귀 (alpha=0.05)
model = Ridge(alpha=0.05)
model.fit(X_train, y_train)
pred = model.predict(X_test)
mean_squared_error(y_test, pred)

# 회귀 계수 (alpha 0.05)
coef['alpha0.05'] = model.coef_
coef

 

 

라쏘 회귀

• 회귀를 위한 선형 모델
• 규제(regularization) 적용
  • 오버피팅 되지 않도록 함
  • 규제 방식 : L1 규제
  • L2에 비해 회귀 계수를 급격히 감소시켜 0으로 만듦
  • L1 규제는 중요한 피처만 선택하는 특성이 있음
    • $J(\theta) = MSE (\theta) + \alpha {1 \over 2} \sum_{i=1}^n \lvert \theta_{i} \rvert$

# 라쏘 회귀
from sklearn.linear_model import Lasso
model = Lasso(alpha=1)
model.fit(X_train, y_train)
pred = model.predict(X_test)
mean_squared_error(y_test, pred)


# 회귀 계수
coef = pd.DataFrame(data=model.coef_, index=X_train.columns, columns=['alpha1'])
coef

# alpha는 학습 데이터 적합 정도와 회귀 계수 값을 크기 제어를 수행하는 튜닝 파라미터

# 라쏘 회귀 (alpha=2)
model = Lasso(alpha=2)
model.fit(X_train, y_train)
pred = model.predict(X_test)
mean_squared_error(y_test, pred)


# 회귀 계수 (alpha=2)
coef['alpha2'] = model.coef_
coef


# 라쏘 회귀 (alpha=0.05)
model = Lasso(alpha=0.05)
model.fit(X_train, y_train)
pred = model.predict(X_test)
mean_squared_error(y_test, pred)


# 회귀 계수 (alpha=0.05)
coef['alpha0.05'] = model.coef_
coef

 

릿지와 라쏘의 차이

• 가중치 제한 방식:
  ◦ 릿지 회귀는 가중치의 제곱합을 제한하는 방식으로 과적합을 방지합니다. 이 방식은 가중치의 절대 크기를 제한하므로 모든 특성의가중치가 비슷하게 작아지는 경향이 있습니다.
  ◦ 라쏘 회귀는 가중치의 절대값의 합을 제한하는 방식으로 과적합을 방지합니다. 이 방식은 일부 가중치를 0으로 만들어 불필요한 특성을 제거하는 효과가 있습니다.
• 특성 선택:
  ◦ 릿지 회귀는 가중치를 작게 만들지만 0으로 만들지는 않습니다. 따라서 모든 특성이 최종 모델에 포함됩니다.
  ◦ 라쏘 회귀는 일부 가중치를 0으로 만들어 불필요한 특성을 제거합니다. 이는 특성 선택(feature selection)이 자동으로 이루어진다는 것을 의미하며, 이로 인해 더 간단하고 해석하기 쉬운 모델을 얻을 수 있습니다.

⇒ 릿지 회귀는 모든 특성이 중요하거나 특성 간의 상관관계가 높은 경우에 좋으며, 라쏘 회귀는 일부 특성만 중요하거나 특성 간의 상관관계가 낮은 경우에 좋습니다.

 

 

엘라스틱넷 회귀

• 회귀를 위한 선형 모델
• L2규제와 L1 규제 결합한 회귀
• 시간이 상대적으로 오래 걸림
  • $ J(\theta) = MSE (\theta) + r\alpha {1 \over 2} \sum_{i=1}^n \lvert \theta_{i} \rvert \ + {1 -r\over 2} \alpha \sum_{i=1}^n {\theta_{i}}^2 $

# 엘라스틱넷 회귀
from sklearn.linear_model import ElasticNet
model = ElasticNet(alpha=1)
model.fit(X_train, y_train)
pred = model.predict(X_test)
mean_squared_error(y_test, pred)


# 엘라스틱넷 회귀
from sklearn.linear_model import ElasticNet
model = ElasticNet(alpha=0.0001, l1_ratio=0.6)
model.fit(X_train, y_train)
pred = model.predict(X_test)
mean_squared_error(y_test, pred)

 

랜덤포레스트 & XGBoost

랜덤포레스트

# 랜덤포레스트
from sklearn.ensemble import RandomForestRegressor
model = RandomForestRegressor()
model.fit(X_train, y_train)
pred = model.predict(X_test)
mean_squared_error(y_test, pred)

 

XGBoost

# XGBoost
from xgboost import XGBRegressor
model =  XGBRegressor()
model.fit(X_train, y_train)
pred = model.predict(X_test)
mean_squared_error(y_test, pred)

 

 

하이퍼파라미터 튜닝

GridSearchCV

# GridSearchCV
xgb = XGBRegressor()
grid = GridSearchCV(xgb, params, cv=3, n_jobs=-1)
grid.fit(X, y)

# 최적의 하이퍼 파라미터를 찾음
grid.best_params_

# 하이퍼파라미터 튜닝
xgb = XGBRegressor(
    learning_rate = 0.05,
    max_depth = 3,
    n_estimators = 100,
    subsample = 0.7
)
xgb.fit(X_train, y_train)
pred = xgb.predict(X_test)
mean_squared_error(y_test, pred)

 

Random Search

## RandomizedSearchCV
xgb = XGBRegressor()
grid = RandomizedSearchCV(xgb, params, cv=3, n_iter=10, n_jobs=-1)
grid.fit(X, y)

# 최적의 하이퍼 파라미터를 찾음
grid.best_params_

 

평가(회귀)

MAE (Mean Absolute Error) : 평균 절대 오차

• 실제 값과 예측 값 차이 → 절댓값 평균
• $ \frac{1}{n} \sum_{i=1}^{n}(\left| y_i - \hat{y_i} \right|) $

MSE (Mean Squared Error) : 평균 제곱 오차

• 실제 값과 예측 값 차이 → 제곱해 평균
• $ \frac{1}{n} \sum_{i=1}^{n}( y_i - \hat{y_i})^2 $

RMSE(Root Mean Squared Error) : MSE에 루트를 씌움

• MSE가 실제 오류보다 커지는 특성이 있어 루트를 활용함
• $ \sqrt {\frac{1}{n} \sum_{i=1}^{n}( y_i - \hat{y_i})^2} $

RMSLE(Root Mean Squared Log Error) : RMSE에 로그 적용

• 예측 값이 실제 값 보다 작을 때 더 큰 패널티 부여 (ex. 배달 : 20분을 예측했는데, 40분 걸리면 문제가 됨)
• $ \sqrt {\frac{1}{n} \sum_{i=1}^{n}( \log(\hat{y_i}+1)-log(y_i+1))^2} $

R2(R Squared Score) : 결정계수

• 실제 값의 분산대비 예측 값의 분산 계산 (1에 가까울 수록 성능이 좋음)
• $ R^2 = 1 - \frac{\sum_{i=1}^{n}(\hat{y_i}- y_i)^2}{\sum_{i=1}^{n}( y_i - \bar{y_i})^2} $

# MAE
from sklearn.metrics import mean_absolute_error
mean_absolute_error(y_test, pred)

# MSE
from sklearn.metrics import mean_squared_error
mean_squared_error(y_test, pred)

# RMSE
import numpy as np
np.sqrt(mean_squared_error(y_test, pred))

# RMSLE
from sklearn.metrics import mean_squared_log_error
np.sqrt(mean_squared_log_error(y_test, pred))

# R2
from sklearn.metrics import r2_score
r2_score(y_test, pred)