[AIB] One Hot Encoding, Feature Selection, Ridge Regression

💡 One-hot Encoding

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns

df = pd.DataFrame({
	'City' : ['Seoul', 'Seoul', 'Seoul', 'Busan', 'Busan', 'Busan', 'Incheon', 'Incheon', 'Seoul', 'Busan', 'Incheon'],
    'Room' : [3, 4, 3, 2, 3, 3, 3, 3, 3, 3, 2],
    'Price' : [55000, 61000, 44000, 35000, 53000, 45000, 32000, 51000, 50000, 40000, 30000]
})

# 데이터 확인
df

output :

 

City 컬럼에 있는 데이터는 도시 지역을 구분하는 범주형 변수 (Categorical variable)이다.

범주형 자료는 순서가 없는 명목형(Nominal)과 순서가 있는 순서형(Ordinal)로 나뉜다.

City 컬럼은 명목형 범주형 변수로 볼 수 있다.

 

City 컬럼처럼 문자열(String) 변수를 처리해야 할 때, 인코딩 방식을 활용한다.

원핫인코딩으로 범주형 데이터를 변환하는 모식도는 아래와 같다.

City	->	Seoul	Busan	Incheon
Seoul		1	0	0
Busan		0	1	0
Incheon		0	0	1

 

원핫인코딩을 수행하면 각 카테고리에 해당하는 변수들이 모두 차원(컬럼)에 더해지게 된다.

따라서 카테고리가 너무 많은 경우(high cardinality)에는 사용하기 적합하지 않다.

 

 

 

✨ 원핫인코딩 예제

# category_encoders 라이브러리 사용
!pip install category_encoders
from category_encoders import OneHotEncoder

features = ['City', 'Room']
target = 'Price'

# 훈련/테스트 데이터 분리
X_train = df[features][:8]
y_train = df[target][:8]
X_test = df[features][8:]
y_test = df[target][8:]

# 원핫인코딩
encoder = OneHotEncoder(use_cat_names=True)
X_train = encoder.fit_transform(X_train)
X_test = encoder.fit_transform(X_test)

 

X_train.head()

output :

X_test

output :

 

 

💡 특성 선택 (Feature Selection)

특성공학은 과제에 적합한 특성을 만들어 내는 과정이다.

그 중에서 특성 선택이 존재하는데 좋은 특성을 선택하는 방법은

특성끼리의 상관도는 낮으면서, 타겟과의 상관도가 큰 특성 조합을 선택하는 것이다.

 

 

✨ 특성 선택 예제

킹카운티 주택 가격 데이터를 사용한다.

# 킹카운티 주택 가격 데이터
df = pd.read_csv('kc_house_data.csv')

# price 값 상위 5%, 하위 5%인 데이터 삭제
# np.percentile 사용
df = df[(df['price'] >= np.percentile(df['price'], 0.05)) &
	(df['price'] <= np.percentile(df['price'], 0.95))]
    
# date 컬럼을 datetime64 타입으로 변환
df['date'] = pd.to_datetime(df['date'])

# 2015-03-01 날짜를 기준으로 훈련/테스트 데이터로 분리
cutoff = pd.to_datetime('2015-03-01')

train = df[df['date'] < cutoff]
test = df[df['date'] >= cutoff]

# 특성 선택을 하기 전, 새로운 특성 생성 및 삭제 진행 = "특성 공학"

def engineer_features(X):
	# pandas.DataFrame.copy()
    X = X.copy()
    
    # 욕실 개수를 정수형으로 변환
    X['bathrooms'] = X['bathrooms'].round(0).astype(int)
    
    # 방 수를 합쳐서 rooms 컬럼으로 합산
    X['rooms'] = X['bedrooms'] + X['bathrooms']
    
    # 사용하지 않을 특성 삭제
    X = X.drop(['id', 'date', 'waterfront'], axis=1)
    
    return X
    
train = engineer_features(train)
test = engineer_features(test)

# 변경된 테이블 확인
train.head()

output :

from math import factorial

# n개의 특성 중에서 k개의 특성을 뽑는 경우의 수
def n_choose_k(n, k):
	return factorial(n) / (factorial(k)*factorial(n-k))
    
n = len(train.columns)
combinations = sum(n_choose_k(n, k) for k in range(1, n+1))

print(combinations)
>>> 524287

k개의 특성을 선택할 수 있는 경우의 수가 너무 많을 때,

좋은 특성만 뽑아주는 SelectKBest 라이브러리를 사용하여 특성을 선택할 수 있다.

target = 'price'

X_train = train.drop(columns=target)
y_train = train[target]
X_test = test.drop(columns=target)
y_test = test[target]

# target 특성인 price 컬럼과 가장 상관도가 높은 feature k개를 선택
from sklearn.feature_selection import f_regression, SelectKBest

# SelectKBest를 사용할 때 score 함수를 사용할 수 있는데
# 회귀 문제에서는 f_reression 을 자주 사용한다.
selector = SelectKBest(score_func=f_regression, k=10)

# 훈련 데이터에 fit_transform
X_train_selected = selector.fit_transform(X_train, y_train)

# 테스트 데이터에는 transform
X_test_selected = selector.transform(X_test)

# 선택된 특성 확인

all_names = X_train.columns

selected_mask = selector.get_support()

# 선택된 컬럼들
selected_names = all_names[selected_mask]

# 선택되지 않은 컬럼들
unselected_names = all_names[~selected_mask]

 

선택할 특성 개수 k를 결정하는 방법

from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_absolute_error, r2_score

training = []
testing = []

# 1 부터 특성 수 만큼 사용한 모델을 만들어서 MAE 값을 비교 합니다.
for k in range(1, len(X_train.columns)+ 1):
    print(f'{k} features')
    
    selector = SelectKBest(score_func=f_regression, k=k)
    
    X_train_selected = selector.fit_transform(X_train, y_train)
    X_test_selected = selector.transform(X_test)
    
    all_names = X_train.columns
    selected_mask = selector.get_support()
    selected_names = all_names[selected_mask]
    print('Selected names: ', selected_names)

    
    model = LinearRegression()
    model.fit(X_train_selected, y_train)
    y_pred = model.predict(X_train_selected)
    mae = mean_absolute_error(y_train, y_pred)
    training.append(mae)
    
    y_pred = model.predict(X_test_selected)
    mae = mean_absolute_error(y_test, y_pred)
    r2 = r2_score(y_test, y_pred)
    testing.append(mae)
    print(f'Test MAE: ${mae:,.0f}')
    print(f'Test R2: {r2} \n')

output :

˙˙˙˙

ks = range(1, len(X_train.columns)+1)

plt.plot(ks, training, label='Training Score', color='b')
plt.plot(ks, testing, label='Testing Score', color='g')
plt.ylabel("MAE ($)")
plt.xlabel("Number of Features")
plt.title('Validation Curve')
plt.legend()
plt.show()

output :

특성 개수 k 값이 5개에서 6개로 넘어갈 때 그래프 상에서 가장 크게 MAE가 감소했다.

모든 특성의 사용하면 당연히 MAE 값은 최소가 되지만 차원이 너무 커져 모델에 영향을 미친다.

따라서 k값은 6개일 때, 가장 효과적이라고 볼 수 있다.

 

 

 

💡 Ridge Regression

Ridge 회귀는 기존의 다중회귀선을 훈련 데이터에 덜 적합되도록 만드는 것이다.

Ridge 회귀모델의 비용함수식은 다음과 같다.

n : 샘플수,   p : 특성수,   λ(람다) : 튜닝 파라미터,   β : 회귀계수

 

릿지 회귀모델의 비용함수를 보면 기존 비용함수인 SSE에 회귀계수제곱합 파트가 추가되었다.

회귀계수제곱합에서 람다는 튜닝 파라미터로, 람다 값이 커질수록 회귀계수들을 0으로 수렴시킨다.

회귀계수값을 0으로 수렴시킴으로써 덜 중요한 특성의 갯수를 줄이는 효과를 낸다. 즉 과적합을 줄인다.

반대로 람다가 0에 가까워지면 릿지 회귀는 다중회귀모델 문제가 된다.

 

Ridge 회귀는 과적합을 줄이기 위해서 사용한다.

과적합을 줄이는 간단한 방법은 모델의 복잡도를 줄이는 방법이다.

특성의 개수를 줄이거나 모델을 단순한 모양으로 적합시키는 것이다.

Ridge 회귀는 편향(Bias)을 조금 더하고, 분산(Variance)을 줄이는 방식으로 정규화(Regularization)를 수행한다.

여기서 말하는 정규화는 모델을 변형하여 과적합을 완화해 일반화 성능을 높여주기 위한 기법을 말한다.

 

 

✨다중회귀모델과 릿지회귀모델 비교

OLS vs Ridge

OLS(Ordinary Least Squares)는 최소자승법으로,

잔차제곱합(RSS: Residual Sum of Squares)을 최소화하는 가중치 벡터를 구하는 방법이다.

Anscome's quartet 데이터 사용

import seaborn as sns
ans = sns.load_dataset('anscombe').query('dataset=="|||"')
ans.plot.scatter('x', 'y')

 

OLS

%matplotlib inline

ax = ans.plot.scatter('x', 'y')

# OLS
ols = LinearRegression()
ols.fit(ans[['x']], ans['y'])

# 회귀계수와 절편(intercept)을 확인한다
m = ols.coef_[0].round(2)
b = ols.intercept_.round(2)
title = f'Linear Regression \n y = {m}x + b'

# 훈련 데이터로 예측
ans['y_pred'] = ols.predict(ans[['x']])

ans.plot('x', 'y_pred', ax=ax, title=title)

output :

 

Ridge Regression

λ 값을 증가시키며 그래프를 통해 회귀계수의 변화를 확인한다.

import matplotlib.pyplot as plt
from sklearn.linear_model import Ridge

def ridge_anscombe(alpha):
	# alpha = lambda
	ans = sns.load_dataset('anscombe').query('dataset=="|||"')
    
    ax = ans.plot.scatter('x', 'y')
    
    ridge = Ridge(alpha=alpha, normalize=True)
    ridge.fit(ans[['x']], ans['y'])
    
    # 회귀계수와 절편(intercept)
    m = ridge.coef_[0].round(2)
    b = ridge.intercept_.round(2)
    title = f'Ridge Regression, alpha={alpha} \n y = {m}x + {b}'
    
    # 훈련 데이터로 예측
    ans['y_pred'] = ridge.predict(ans[['x']])
    
    ans.plot('x', 'y_pred', ax=ax, title=title)
    plt.show()
    
    
# 여러 alpha 값으로 그래프를 그린다
alphas = np.arange(0, 2, 0.4)
for alpha in alphas:
	ridge_anscombe(alpha)

output :

그래프를 보면, alpha = 0 인 경우에는 OLS와 같은 그래프 형태를 보이므로 같은 모델임을 확인할 수 있고,

alpha 값이 커질수록 직선의 기울기가 0에 가까워지면서 평균 기준모델(baseline)과 비슷해지는 모습을 볼 수 있다.

최적의 패널티 값으로 예측된 Ridge 회귀 직선은 이상치 영향을 덜 받을 수 있다.

 

최적 패널티 값인 alpha 값을 효율적으로 구하기 위해서는, 여러 패널티 값을 가지고 교차검증 (cross-validation)을

사용하여 찾아나가야 한다.

sklearn의 RidgeCV 라이브러리를 사용하면 교차검증 알고리즘을 자체적으로 진행해 최적의 패널티 값을 찾는다.

 

 

✨ RidgeCV를 통한 최적 패널티 검증

from sklearn.linear_model import RidgeCV

alphas = [0.01, 0.05, 0.1, 0.2, 1.0, 10.0, 100.0]

ridge = RidgeCV(alphas=alphas, normalize=True, cv=3)
ridge.fit(ans[['x']], ans['y'])
print("alpha: ", ridge.alpha_)
print("best score: ", ridge.best_score_)

output :

 

cf.

sklearn.linear_model.RidgeCV

: cv 파라미터를 통해서 K-fold 교차검증을 지정할 수 있다.

 

 

 

reference

https://modern-manual.tistory.com/21

Ridge regression(능형 회귀) 간단한 설명과 장점

https://velog.io/@dlskawns/Linear-Regression-Ridge-Regression-RidgeCV-%EC%A0%95%EB%A6%AC

Linear Regression - Ridge Regression, RidgeCV 정리