1. 전체 칼럼명 바꾸기

# pandas libary import
import pandas as pd
df = pd.read_csv("./sample.csv")
df.columns = ["renameA", "renameB", "renameC"]

df.columns = [ 바꾸고 싶은 칼럼 명 리스트], 이렇게 괄호 안에 명시해 주시면 됩니다.

2. 특정 칼럼명 바꾸기

또는 특정 칼럼만 이름을 바꾸고 싶다면 아래처럼 코드를 실행시켜주시면 됩니다. 아래 코드를 실행하게 되면 결과적으로 기존의 price 라는 칼럼 명이 log(price) 로 바뀌게됩니다.

test_df.rename(columns={'price': 'log(price)'})

LightGBM에 관한 좋은 medium 포스트가 있어서 한글로 번역한 내용을 공유드려봅니다 🙂 

Pushkar Mandot의 원문 바로가기:

View at Medium.com

안녕하세요, 머신러닝은 이 세상에서 가장 빠르게 성장하는 분야입니다. 매일 새로운 알고리즘들이 출시되고, 그 중 몇 개는 실패하고 몇 개는 성공합니다. 오늘, 저는 그 중에서도 가장 성공적인 알고리즘 중 하나인, Light GBM을 소개하려고 합니다.

무엇이 저로 하여금 LightGBM에 대한 블로그를 작성하도록 동기부여했을까요?

Kaggle 데이터 분석 경진대회에서 작업할 동안, 저는 여러 개의 강력한 알고리즘들을 접하게 되었습니다. LightGBM은 그 중 하나였죠. LightGBM은 상대적으로 새로운 알고리즘이었고, 인터넷에 공식 문서를 제외하고는 읽기 자료가 많이 없었습니다. 그래서 다큐먼트 상의 길게 나열된 파라미터들로부터 초보자가 파라미터를 선택하는 것은 어려웠죠. 신규 입문자분들을 돕기 위해 저는 이 블로그 글을 쓰게 되었습니다.

수백 개의 불필요한 정보를 추가하는 것은 배우는 입장에서 혼란스러울 수 있기 때문에 이 블로그 글을 간결하게 작성하기 위해 최선을 다하겠습니다.

Light GBM은 무엇일까요?

Light GBM은 Gradient Boosting 프레워크로 Tree 기반 학습 알고리즘입니다.

기존의 다른 Tree 기반 알고리즘과 어떻게 다를까요?

Light GBM은 Tree가 수직적으로 확장되는 반면에 다른 알고리즘은 Tree가 수평적으로 확장됩니다, 즉 Light GBM은 leaf-wise 인 반면 다른 알고리즘은 level-wise 입니다. 확장하기 위해서 max delta loss를 가진 leaf를 선택하게 되는 것이죠. 동일한 leaf를 확장할 때, leaf-wise 알고리즘은 level-wise 알고리즘보다 더 많은 loss, 손실을 줄일 수 있습니다.

아래 다이어그램은 LightGBM와 다른 Boosting 부스팅 알고리즘의 구현을 나타내고 있습니다.

Light GBM은 어떤 이유로 엄청난 인기를 얻게 되었을까요?

데이터 사이즈는 날이 갈수록 커지고 있고 전통적인 데이터 분석 알고리즘으로 빠른 결과를 얻기란 더욱 어려워졌습니다. Light GBM은 말 그대로 “Light” 가벼운 것인데요, 왜냐면 속도가 빠르기 때문입니다. Light GBM은 큰 사이즈의 데이터를 다룰 수 있고 실행시킬 때 적은 메모리를 차지합니다. Light GBM이 인기있는 또 다른 이유는 바로 결과의 정확도에 초점을 맞추기 때문입니다. LGBM은 또한 GPU 학습을 지원하기 때문에 데이터 사이언티스트가 데이터 분석 어플리케이션을 개발할 때 LGBM을 폭넓게 사용하고 있습니다.

Light GBM은 어디서나 사용할 수 있을까요?

아닙니다. LGBM을 작은 데이터 세트에 사용하는 것은 추천되지 않습니다. Light GBM은 overfitting (과적합)에 민감하고 작은 데이터에 대해서 과적합하기 쉽습니다. row (행) 수에 대한 제한은 없지만 제 경험상 10,000 이상의 row (행) 을 가진 데이터에 사용하는 것을 권유해드립니다.

Light GBM에 대한 컨셉에 대해 대략적으로 논의해보았는데요, 구현은 어떻게 하면 될까요?

Light GBM 구현은 쉽습니다. 다만 한 가지 복잡한 것은 파라미터 튜닝입니다. Light GBM은 100개 이상의 파라미터를 커버하고 있기 때문입니다. 그러나 걱정 마세요 모든 것을 배워야하는 것은 아닙니다.

Light GBM의 가장 베이직한 파라미터를 아는 것이 구현 시 매우 중요합니다. 아래 소개되는 파라미터들을 주의깊게 따라가다보면, 이토록 강력한 알고리즘이 여러분께 매우 쉬운 영역이라는 것을 말씀드립니다.

이제 파라미터에 대한 논의로 넘어가보도록 하겠습니다.

Parameters 

파라미터 소개

max_depth : Tree의 최대 깊이를 말합니다. 이 파라미터는 모델 과적합을 다룰 때 사용됩니다. 만약 여러분의 모델이 과적합된 것 같다고 느끼신다면 제 조언은 max_depth 값을 줄이라는 것입니다.

min_data_in_leaf : Leaf가 가지고 있는 최소한의 레코드 수입니다. 디폴트값은 20으로 최적 값입니다. 과적합을 해결할 때 사용되는 파라미터입니다.

feature_fraction : Boosting (나중에 다뤄질 것입니다) 이 랜덤 포레스트일 경우 사용합니다. 0.8 feature_fraction의 의미는 Light GBM이 Tree를 만들 때 매번 각각의 iteration 반복에서 파라미터 중에서 80%를 랜덤하게 선택하는 것을 의미합니다.

bagging_fraction : 매번 iteration을 돌 때 사용되는 데이터의 일부를 선택하는데 트레이닝 속도를 높이고 과적합을 방지할 때 주로 사용됩니다.

early_stopping_round : 이 파라미터는 분석 속도를 높이는데 도움이 됩니다. 모델은 만약 어떤 validation 데이터 중 하나의 지표가 지난 early_stopping_round 라운드에서 향상되지 않았다면 학습을 중단합니다. 이는 지나친 iteration을 줄이는데 도움이 됩니다.

lambda : lambda 값은 regularization 정규화를 합니다. 일반적인 값의 범위는 0 에서 1 사이입니다.

min_gain_to_split : 이 파라미터는 분기하기 위해 필요한 최소한의 gain을 의미합니다. Tree에서 유용한 분기의 수를 컨트롤하는데 사용됩니다.

max_cat_group : 카테고리 수가 클 때, 과적합을 방지하는 분기 포인트를 찾습니다. 그래서 Light GBM 알고리즘이 카테고리 그룹을 max_cat_group 그룹으로 합치고 그룹 경계선에서 분기 포인트를 찾습니다. 디폴트 값은 64 입니다.

Core Parameters

핵심 파라미터 소개

Task : 데이터에 대해서 수행하고자 하는 임무를 구체화합니다. train 트레이닝일 수도 있고 predict 예측일 수도 있습니다.

application : 가장 중요한 파라미터로, 모델의 어플리케이션을 정하는데 이것이 regression 회귀분석 문제인지 또는 classification 분류 문제인지를 정합니다. Light GBM에서 디폴트는 regression 회귀분석 모델입니다.

• regression: 회귀분석
• binary: 이진 분류
• multiclass: 다중 분류

boosting : 실행하고자 하는 알고리즘 타입을 정의합니다. 디폴트값은 gdbt 입니다.

• gdbt : Traditional Gradient Boosting Decision Tree
• rf : Random Forest
• dart : Dropouts meet Multiple Additive Regression Trees
• goss : Gradient-based One-Side Sampling

num_boost_round : boosting iteration 수로 일반적으로 100 이상입니다.

learning_rate : 최종 결과에 대한 각각의 Tree에 영향을 미치는 변수입니다. GBM은 초기의 추정값에서 시작하여 각각의Tree 결과를 사용하여 추정값을 업데이트 합니다. 학습 파라미터는 이러한 추정에서 발생하는 변화의 크기를 컨트롤합니다. 일반적인 값은 0.1, 0.001, 0.003 등등이 있습니다.

num_leaves : 전체 Tree의 leave 수 이고, 디폴트값은 31입니다.

device : 디폴트 값은 cpu 인데 gpu로 변경할 수도 있습니다.

Metric parameter

지표 파라미터

metric : 모델을 구현할 때 손실을 정하기 때문에 중요한 변수 중에 하나입니다. regression과 classification 을 위한 일반적인 손실 값이 아래에 나와있습니다.

• mae : mean absolute error
• mse : mean squared error
• binary_logloss : loss for binary classification
• multi_logloss : loss for multi classification

IO parameter

IO 파라미터

max_bin : feature 값의 최대 bin 수를 의미합니다.

categorical_feature : 범주형 feature의 인덱스를 의미합니다. 만약 categorical_features 가 0, 1, 2 이면 column 0, column 1, column 2 가 범주형 변수들입니다.

ignore_column : categorical_features와 동일한 것인데 범주형 feature로써 특정 칼럼을 고려하지 않는 것입니다. 그 변수들을 무시하는 것입니다.

save_binary : 데이터 파일의 메모리 사이즈를 처리해야 한다면 이 파라미터 값을 True로 설정하십시오. 이 값을 True로 세팅하면 데이터 세트를 바이너리 파일로 저장할 것이고, 이 바이너리 파일은 다음에 데이터를 읽어올 때 그 속도를 줄여줄 것입니다.

위에 설명드린 파라미터들을 알고 사용하는 것은 모델을 구현할 때 도움이 될 것입니다. LightGBM 모델 구현은 쉽지만 파라미터 튜닝은 어렵다는 것을 앞서 말씀드렸습니다. 이제 구현을 시작해보도록 하겠습니다. 제가 파라미터 튜닝에 대한 아이디어를 그 과정에서 드리도록 하겠습니다.

모델 구현

LGBM 설치하기 :

LightGBM을 설치하는 것은 중요한 작업입니다. 저는 LightGBM 설치에 대한 좋은 리소스를 찾아냈고 가이드를 드리도록 하겠습니다.

저는 Anaconda를 사용하고 있고 LightGBM을 아나콘다에 설치하는 것은 가능합니다. 단지 Anaconda 명령 프롬프트 창에서 다음의 명령어를 실행시켜주시면 됩니다.

conda install -c conda-forge lightgbm

데이터 세트:

이 데이터는 400개의 행과 5개의 칼럼으로 구성된 매우 작은 데이터입니다. (학습 목적으로 특별히 사용되는 것입니다.) classification 분류 문제로, 웹사이트 광고에 나온 제품을 살지를 예측하는 문제입니다. 데이터 세트는 여기서 다운로드가 가능합니다.

Note: 이 데이터 세트는 깨끗하고 결측치가 없습니다. 매우 단순한 데이터를 고른 이유는 튜토리얼이 단순하고 이해가 쉽도록 하기 위해서입니다.

저는 이 설명을 읽는 분들이 Python의 기본을 안다고 가정하겠습니다. 데이터 전처리 스텝을 쉽게 따라가실 수 있지만 만약 코멘트란에 물어보고 싶은 것이 있으시다면 답변을 드리도록 하겠습니다.

데이터 전처리 :

import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
# Importing the dataset
dataset = pd.read_csv('...input\Social_Network_Ads.csv')
X = dataset.iloc[:, [2, 3]].values
y = dataset.iloc[:, 4].values
# Splitting the dataset into the Training set and Test set
from sklearn.cross_validation import train_test_split
x_train, x_test, y_train, y_test = train_test_split(X, y, test_size = 0.25, random_state = 0)
# Feature Scaling
from sklearn.preprocessing import StandardScaler
sc = StandardScaler()
x_train = sc.fit_transform(x_train)
x_test = sc.transform(x_test)

모델 빌드 및 트레이닝 :

트레이닝 데이터를 LightGBM에 맞는 데이터 세트 포맷으로 변환해야합니다. (LightGBM 트레이닝에 있어서 필수적입니다.)

변환된 데이터 세트 생성 이후에, 파라미터와 그 값으로 구성된 Python Dictionary 파이썬 딕셔너리를 생성했습니다. 모델의 정확도는 설정된 파라미터 값에 전적으로 달려 있습니다.

import lightgbm as lgb
d_train = lgb.Dataset(x_train, label=y_train)
params = {}
params['learning_rate'] = 0.003
params['boosting_type'] = 'gbdt'
params['objective'] = 'binary'
params['metric'] = 'binary_logloss'
params['sub_feature'] = 0.5
params['num_leaves'] = 10
params['min_data'] = 50
params['max_depth'] = 10
clf = lgb.train(params, d_train, 100)

파라미터에서 봐야할 일부 요소들 :

• “binary” 가 objective 로 사용됨 (이것이 classification 분류 문제라는 것을 기억해주십시오)
• “binary_logloss”가 metric 으로 사용됨 (마찬가지 이유로, binary classification 문제라는 것을 기억해주십시오)
• num_leaves 는 10 (왜냐면 작은 데이터이기 때문입니다)
• boosting type 은 gbdt 인데, gradient boosting 을 구현하고 있기 때문입니다. (random forest 를 시도하실 수 있습니다.)

모델 예측 :

예측을 위한 몇 줄의 코드를 작성해야합니다.

결과는 확률 리스트일 것입니다. 저는 확률을 binary prediction으로 변환했고 threshold 값은 0.5로 유지했습니다.

#Prediction
y_pred=clf.predict(x_test)
#convert into binary values
for i in range(0,99):
    if y_pred[i]>=.5:       # setting threshold to .5
       y_pred[i]=1
    else:  
       y_pred[i]=0

결과 :

confusion matrix 나 또는 바로 accuracy를 계산해서 결과를 확인할 수 있습니다.

Code :

#Confusion matrix
from sklearn.metrics import confusion_matrix
cm = confusion_matrix(y_test, y_pred)
#Accuracy
from sklearn.metrics import accuracy_score
accuracy=accuracy_score(y_pred,y_test)

결과 스크린샷 :

어떤 분들은 데이터 세트가 작았는데 모델 정확도가 92%나 되었다고 생각하실 수도 있겠습니다. 과적합은 왜 발생하지 않았을까요? 가장 단순한 이유는 모델 파라미터를 튜닝했기 때문입니다.

이제 파라미터 튜닝 문제로 넘어가도록 하겠습니다.

파라미터 튜닝 :

데이터 사이언티스트는 언제나 어떤 파라미터를 언제 사용할지 그리고 어떤 값이 최적의 파라미터 값일지 결정하기 위해 고민합니다.

아래 소개되는 기법들은 모델 정확도를 향상시키기 위해 사용될 수 있습니다.

1. num_leaves : Tree 모델의 복잡성을 컨트롤하는 주요 파라미터입니다. 이상적으로 num_leaves 값은 2 ^ (max_depth) 값보다 적거나 같아야 합니다. 이것보다 많은 값은 과적합을 유발할 것입니다.
2. min_data_in_leaf : 큰 값으로 세팅하는 것은 Tree가 너무 깊게 확장되는 것을 막을 수 있지만 under-fitting 언더 피팅이 발생할 수도 있습니다. 관행적으로, 수백 또는 수천 개로 정하는 것이 큰 데이터 세트에 충분합니다.
3. max_depth : Tree 깊이를 명확하게 제한하기 위해 max_depth 값을 설정할 수도 있습니다.

더 빠른 속도를 위하여 :

• bagging_fraction과 baggin_freq 을 설정하여 bagging 을 적용하십시오
• feature_fraction을 설정하여 feature sub-sampling을 하십시오
• 작은 max_bin 값을 사용하십시오
• save_binary 를 값을 통해 다가오는 학습에서 데이터 로딩 속도를 줄이십시오
• parallel learning 병렬 학습을 적용하십시오

더 나은 정확도를 위해 :

• 큰 max_bin 값을 사용하십시오 (아마 속도는 느려질 수 있습니다)
• 작은 learning_rate 값을 큰 num_iterations 값과 함께 사용하십시오
• 큰 num_leaves 값을 사용하십시오 (아마 과적합을 유발할 수도 있습니다)
• 더 큰 트레이닝 데이터를 사용하십시오
• dart 를 사용하십시오
• 범주형 feature를 사용하십시오

과적합을 해결하기 위해 :

• 작은 max_bin 값을 사용하십시오
• 작은 num_leaves 값을 사용하십시오
• min_data_in_leaf 와 min_sum_hessian_in_leaf 파라미터를 사용하십시오
• bagging_fraction 과 bagging_freq 을 사용하여 bagging 을 적용하십시오
• feature_fraction을 세팅하여 feature sub-sampling을 하십시오
• lambda_l1, lambda_l2 그리고 min_gain_to_split 파라미터를 이용해 regularization (정규화) 를 적용하십시오
• max_depth 를 설정해 Deep Tree 가 만들어지는 것을 방지하십시오

결론 :

저는 다양한 데이터 세트에서 LightGBM 을 구현해보았고 다른 부스팅 알고리즘보다 정확도가 좋다는 것을 발견하였습니다. 제 경험상, 이 알고리즘을 적어도 한 번은 시도해보는 것을 추천드립니다.

이 블로그를 읽는 것이 도움이 되었으면 좋겠습니다. 이 블로그를 발전시키기 위한 제안을 주시면 감사하겠습니다.

출처 : Microsoft LightGBM Documentation

감사합니다,

Pushkar Mandot

• 

Xgboost 알고리즘! 오늘은 Xgboost 알고리즘 공부한 내용에 대해 공유하려고 합니다.

Xgboost는 Extreme Gradient Boost라고 해서 Decision Tree 기반 앙상블 머신러닝 알고리즘인데 Gradient Boosting 프레임워크를 사용합니다. Structured Data (정형 데이터)를 가지고 예측할 때 매우 우수한 성능을 보이는 알고리즘으로 주목을 받았습니다. Regression 또는 Classification 같은 예측 분석에 사용됩니다.

Datacamp라는 웹사이트에서 Xgboost라는 알고리즘에 대해서 굉장히 잘 정리해주어서 이 글을 살펴보시는 것을 추천드려봅니다 🙂

Datacamp Xgboost 튜토리얼 바로가기

그리고 이론적으로 잘 설명하고 있는 글도 소개해봅니다.

Xgboost 이론 설명 바로가기

이외에도 홈페이지 글도 좋아서 공유해봅니다~

Xgboost 홈페이지 설명 바로가기

Xgboost 알고리즘 메소드는 다음과 같습니다. Regression 모델인 경우, 모델 오브젝트를 아래와 같이 생성해서 predict 할 수 있는데요, 자세한 내용은 Datacamp의 튜토리얼 링크에서 보면 좋습니다. 여기서 아래 code snippet에 사용된 parameter 값에 대한 summary를 하려고 합니다.

xg_reg = xgb.XGBRegressor(objective ='reg:linear', colsample_bytree = 0.3, 
learning_rate = 0.1,max_depth = 5, alpha = 10, n_estimators = 10)

1. objective

objective 는 loss function 손실함수입니다. reg:linear라는 부분은 linear regression 모델의 손실함수를 사용한다는 의미겠죠. 이 부분은 gradient boosting이 적용되어서 그런 것 같습니다. 즉 예측한 값과 실제 값의 차이를 줄이는 프레임워크이다보니 loss function의 개념이 들어간 것 같습니다.

2. colsample_bytree

각 tree별 사용된 feature의 퍼센테이지라고 합니다. 값이 높을수록 오버피팅이 됩니다.

3. learning_rate

학습속도

4. max_depth

Boosting 시에 얼마나 각각의 tree가 깊게 커질 수 있는지에 대한 정도

5. alpha

L1 regularization 값인데 큰 값일 수록 더 regularization 하는 것입니다. (모델의 복잡도를 줄이고 over fitting을 줄이기 위해서)

6. n_estimators

빌드하고 싶은 tree의 수입니다.

다른 분들도 혹시 공부하시다가 글을 보면서 가볍게 정리할 수 있으면 좋을 것 같아 글을 작성해보았습니다. 이상입니다. 감사합니다 🙂

데이터 분석을 공부하다보면 흔하게 마주치는 이름들이 있습니다. Linear, Ridge, Lasso, elasticNet… 회귀모델 4인방입니다. 어디선가 한 번 쯤 들어본 듯한 이분들(?)에 대해 최대한 쉬운 언어로 + Python 핸즈온 코드로 정리해보도록 노력하였습니다.

Ridge, Lasso, elasticNet의 경우는 수식을 전부 이해하시지 않더라도 sklearn에서 세 모델을 돌리기위해서 조정하는 값은 alpha 하나이기 때문에 코드를 돌리시는 데는 무리가 없지만 그래도 alpha라는 값이 모델에서 어떤 의미인지 이해하기 위해서는 수식에 대한 설명을 따라오시면 좋을 것 같습니다.

+ 이 글에서 Ridge 회귀모델을 잘 이해할 수 있다면 나머지 Lasso, elasticNet은 응용되는 개념이기 때문에 좀 더 순조롭게 이해하실 수 있습니다. 수식이 이해가 되지 않으시더라도 괜찮습니다!! 지금은 이해 안 가셔도 나중에 갑자기 이해가 되실 수 있으니 편안하게 읽어주시면 좋습니다.

설명 중간 중간 나오는 파이썬 코드 전체는 아래 github을 참고해주시면 됩니다.

https://github.com/entheos37/data_science/blob/master/regression/Data_Science_Model_Summary.ipynb

1. Linear Regression 선형 회귀 모델

위에 공식은 위키백과에서 복사 붙여넣기를 한 것인데요, 쉽게 얘기하면 y라는 종속변수와 한 개 이상의 설명 변수(=독립변수) x들과의 선형 상관관계를 모델링하는 회귀 분석 모델이 바로 Linear Regression, 선형 회귀 모델입니다.

좀 더 쉽게 예시를 들어보겠습니다. 파운드와 킬로그램은 선형적 상관 관계를 가지고 있습니다. 7개 데이터를 가지고 점을 찍어보면 파운드 x와 킬로그램 y는 대략적으로 선형적 관계를 가지고 있다는 것을 확인할 수 있습니다. 즉 파운드 x 값에 어떤 weight를 곱하고 bias를 더해주면 킬로그램 y 값이 나오는 것입니다.

이제 sklearn 사이킷런 라이브러리의 LinearRegression 모델을 임포트해서 pound 데이터를 x, kilogram 데이터를 y로 학습시킨 후 해당 모델로 30 pounds가 몇 kilograms인지 예측해보도록 하겠습니다.

# load library
import numpy as np
from sklearn.linear_model import LinearRegression
import matplotlib.pyplot as plt
%matplotlib inline
import warnings warnings.filterwarnings("ignore", category=DeprecationWarning)

# define data
kilograms = np.array([49, 10, 0, 21, 44, 2, 100], dtype=float).reshape((-1,1))
pounds = np.array([108.027, 22.0462, 0, 46.2971, 97.0034, 4.40925, 220.462], dtype=float).reshape((-1,1))

for i,c in enumerate(kilograms):
	print("%s Kilograms = %s Pounds" %(c, pounds[i]))

이렇게 하면 결과가 아래와 같이 출력됩니다. 49 킬로그램은 108.027 파운드이구요, 10 킬로그램은 22.0462 파운드입니다. 이 데이터를 그래프로 그린 게 바로 위에 보여지는 scatter plot 산점도입니다.

[49.] Kilograms = [108.027] Pounds
[10.] Kilograms = [22.0462] Pounds
[0.] Kilograms = [0.] Pounds
[21.] Kilograms = [46.2971] Pounds
[44.] Kilograms = [97.0034] Pounds
[2.] Kilograms = [4.40925] Pounds
[100.] Kilograms = [220.462] Pounds

이제 이 데이터를 가지고 선형회귀 모델로 학습을 해서 과연 30 파운드는 몇 킬로그램인지를 예측해보도록 하겠습니다~!

from sklearn.linear_model import LinearRegression
# create a linear regression model
model = LinearRegression()

# train data
model.fit(pounds, kilograms)

# predict data - 30.0 pounds to kilograms
result_kilograms = model.predict([[30.0]])

print('30.0 pounds >> %s kilograms' %(result_kilograms[0][0]))

30 파운드가 바로 아래처럼 약 13.6078 킬로그램인 것을 알 수 있습니다.

30.0 pounds >> 13.607745297753652 kilograms

구글에 pounds to kg 로 쳐보시면 놀랍도록!! 선형회귀로 예측한 결과가 정확하신 것을 보실 수 있습니다.  

# print weights and bias
print(model.coef_[0][0])
print(model.intercept_[0])

weights와 bias를 출력해보면 값은 아래와 같습니다.

0.4535926229261759
-3.3390031624946914e-05

이를 다시 공식화 해보면, 아래 수식이 됩니다.

y (kilograms) = 0.4535926229261759 * x (pounds) + (-3.3390031624946914e-05)

이 수식으로 다시 계산해보면 모델이 예측한 값과 동일한 것을 더블 체크해볼 수 있습니다.

# re-calculate based on the weights and bias
# output y kilograms = input x pounds * weights + bias
# 13.607745297753652 = 30.0 * 0.4535926229261759 + -3.3390031624946914e-05
30.0*model.coef_[0][0]+model.intercept_[0]

13.607745297753652

위에서 점으로 그렸던 실제 데이터 산점도 위에 모델로 예측한 값이 얼마나 일치하는지 그래프로 시각화 해보겠습니다.

# draw data with linear regression model
plt.title('Kilograms and Pounds')
plt.xlabel('Pounds')
plt.ylabel('Kilograms')
plt.plot(pounds, kilograms,'k.')
plt.grid(True)
plt.plot(pounds, model.predict(pounds))

보시면 실제 데이터 (점) 과 예측한 모델 (선) 이 겹치는 것을 보실 수 있습니다.

이제 회귀분석 몸풀기로 Linear Regression을 살펴보았으니~~ 그 다음으로 Ridge, Lasso, elasticNet Regression 모델을 살펴보겠습니다.

2. Ridge 릿지 & Lasso 라쏘 & elasticNet 엘라스틱넷 Regression

Ridge, Lasso, elasticNet 회귀 분석에서는 multicollinearity 다중공선성 문제와 over-fitting 과적합 문제 방지를 위해 아래와 같은 정규화 방식이 적용되었습니다.

• Ridge 회귀 모델은  L2 정규화
• Lasso 회귀모델은 L1 정규화
• elasticNet은 Ridge의 L2와 Lasso의 L1 정규화 혼합

+ 여기서 multicollinearity 다중공선성이란 독립변수 x들간의 강한 상관관계가 나타나서, 독립변수들이 독립적이지 않는 문제가 발생하게 되는 현상을 말합니다. 이 경우 coefficient 추정치가 부정확해지고 standard error 값이 높아지게 됩니다.

참고로 Ridge, Lasso 수식에 대한 설명은 Saptashwa Bhattacharyya 님의 글을 참고하였습니다.

https://towardsdatascience.com/ridge-and-lasso-regression-a-complete-guide-with-python-scikit-learn-e20e34bcbf0b

Cost Function 비용함수는 간단하게 말하면 y (실제 결과값)과 y^ (모델로 추정한 결과값)의 차이(에러)를 제곱해서 합한 것입니다. 차이를 그냥 다 더하지 않고 제곱한 이유는 그냥 전부 더하면 0이 되버리기 때문에 차이에 대한 제곱을 더한 것입니다. 실제로 손수 계산해서 해보시면 제곱 안 하고 다 더하는 경우 0이 되는 것을 확인하실 수 있습니다.

+ 참고로 MSE라고 흔히 줄여서 말하는 Mean Squared Error는 Cost Function을 데이터 수 n만큼 나눠준 것이라고 보시면 됩니다.

Ridge 릿지 회귀는  Linear Regression 선형 회귀모델의 Cost Function 비용함수에 페널티를 적용한 것입니다. 여기서 페널티는 Lambda * 계수 coefficient 제곱의 합입니다. 이때 Lambda 값이 0에 가까워지면 Ridge는 본래 Linear Regression의 Cost Function에 가까워지게 됩니다.

반면에 Lambda의 값이 어느 정도 크다면, coefficient의 크기가 줄어서(0에 가까워져서) 모델의 복잡도가 줄어들고 multicollinearity 문제의 영향을 줄어들게 할 수 있게 됩니다. 왜냐면 서로 영향을 미치는 독립변수들의 weight가 줄어드는 것이기 때문입니다.

이제 Lasso 라쏘 회귀를 살펴보겠습니다.

Ridge와 수식은 비슷하지만 한 가지 차이점은, 페널티의 계산이 Lambda * coefficient 제곱합이 아니라 Lambda * coefficient 절대값의 합이라는 것입니다. 이 계산은 L1 정규화 방식이고, zero coefficient 를 만드는 것이 가능해집니다. 즉, 어떤 독립변수의 경우 아예 사라지게 될 수도 있게 되면서 feature selection, 상대적으로 더 중요한 독립변수를 선택할 수 있게 됩니다.

Lasso는 특정 독립변수의 coefficient 값을 0으로 만들 수 있고 Ridge는 0에 가까워지게 하지만 Lasso처럼 0으로 만들 수는 없다는 차이점이 있습니다.

https://hackernoon.com/an-introduction-to-ridge-lasso-and-elastic-net-regression-cca60b4b934f

위 사이트에서 elasticNet의 공식을 참고하였습니다.

+ 참고로 위 사이트는 에러 제곱합을 2n으로 나누어주었는데요 위에 MSE 설명 참고하시면 MSE란 에러 제곱합의 평균인데 의미적으로는 크게봤을 때 에러 제곱합이다 >> 라고 보시면 됩니다.

원래 Linear Regression의 비용함수에다가 penalty 함수가 있는데 이 penalty 함수의 구성이 원래 Ridge는 Lambda*계수 제곱합 ==> L2 정규화이었고, Lasso는 Lambda *계수 절대값 합 ==> L1 정규화 였습니다.

elasticNet은 (1-alpha)/2 * Ridge의 L2 정규화+ alpha * Lasso의 L1 정규화

즉 Ridge의 L2, Lasso의 L1을 합쳐서 비용함수를 계산한 것이라고 보면 됩니다.

alpha가 0에 가까우면 elasticNet은 Ridge에 가까워지고, alpha가 1에 가까우면 elasticNet은 Lasso에 가까워지게 됩니다. elasticNet을 사용하게 되면 Ridge처럼 coefficient의 크기를 줄이면서 Lasso처럼 특정 coefficient를 0으로 만들어 버리면서 특정 독립변수를 사라지게 하는 feature selection 효과를 누릴 수 있게 됩니다.

이제 sklearn 사이킷런의 관련 라이브러리들을 임포트해서 간단한 데이터로 핸즈온을 해보도록 하겠습니다. 참고한 코드는 아래 주석에 출처 표시가 되어있습니다. Ridge에 대해서만 코드를 살펴보도록 하겠습니다. 나머지 Lasso, elasticNet 구현은 비슷한 로직으로 되어있기 때문에 제 Github을 참고해주시면 됩니다.

# Reference
# https://www.datatechnotes.com/2019/08/elasticnet-regression-example-in-python.html
# https://towardsdatascience.com/ridge-and-lasso-regression-a-complete-guide-with-python-scikit-learn-e20e34bcbf0b

#load library
from sklearn.datasets import load_boston
from sklearn.linear_model import Ridge, RidgeCV, Lasso, LassoCV, ElasticNet,ElasticNetCV
from sklearn.metrics import mean_squared_error
from sklearn.model_selection import train_test_split
import matplotlib.pyplot as plt
import numpy as np

# load boston house price data
boston=load_boston()
x, y = boston.data, boston.target
xtrain, xtest, ytrain, ytest = train_test_split(x, y, test_size=0.2,random_state=3)

alphas = [0.0001, 0.001, 0.01, 0.1, 0.3, 0.5, 0.7, 1]

# Ridge Regression
# select alpha 0.0001 or 0.001 or 0.01 by checking R2, MSE, RMSE
for a in alphas:
model = Ridge(alpha=a).fit(x,y)
score = model.score(x, y)
pred_y = model.predict(x)
mse = mean_squared_error(y, pred_y)
print("Alpha:{0:.4f}, R2:{1:.2f}, MSE:{2:.2f}, RMSE:{3:.2f}"
.format(a, score, mse, np.sqrt(mse)))

위 코드를 보시면 alpha를 0.0001 또는 0.001 또는 0.01 로 선택해야겠다는 판단을 할 수 있는데요 R2는 제일 높고(제일 설명력이 좋고), MSE(Mean Squared Error)와 RMSE(Root Mean Squared Error)는 제일 낮은 값을 기준입니다.

이렇게 봤을 때 좀 애매할 수 있어서 Cross Validation 을 돌려서 최적의 alpha를 출력해보도록 하겠습니다.

+ Cross Validation이란 데이터 세트를 여러 등분을 해서 반복적으로 교차 검증 (트레이닝 및 테스트)를 돌리는 것입니다. 나중에 기회가 되면 Cross Validation Test에 대해서 정리해보도록 하겠습니다.

# run Ridge cross validation test to find the best alpha based on training data
ridge_cv=RidgeCV(alphas=alphas, cv=5)
model = ridge_cv.fit(xtrain, ytrain)
print(model.alpha_)

cv를 5로 했다는 것은 5등분을 해서 교차검증을 5번 했다고 보시면 됩니다. 위에 코드를 실행시키면 결과적으로 alpha는 0.0001이 출력되는데요, 이 말은 alpha를 0.0001로 했을 때 테스트 세트에 대한 예측이 확률적으로 좋았다는 것입니다.

# calculate Ridge R2, MSE, RMSE from test data
ridge=Ridge(alpha=0.0001).fit(xtrain, ytrain)
ypred_ridge = ridge.predict(xtest)
score_ridge = ridge.score(xtest, ytest)
mse_ridge = mean_squared_error(ytest, ypred)
print("Final Result: Ridge R2:{0:.3f}, MSE:{1:.2f}, RMSE:{2:.2f}"
.format(score_ridge, mse_ridge, np.sqrt(mse_ridge)))

Final Result: Ridge R2:0.795, MSE:16.96, RMSE:4.12

최종적으로 테스트 세트에 대해서 Ridge를 가지고 예측한 결과 R2 값은 0.795, MSE는 16.96, RMSE는 4.12로 아까 트레이닝 세트를 가지고 간이로 예측했을 때보다(alpha 0.0001 기준)도 더 좋은 결과를 낸 것을 알 수 있습니다.

나머지 Lasso와 elasticNet 결과는 아래 github에 올라온 코드를 참고해주시면 됩니다.

그림을 그려보면 original boston house price에 대해서 ridge, lasso, elasticNet의 그래프가 겹치는 것을 보아 비슷한 예측 결과를 보였다는 것을 시각적으로 확인해볼 수 있었습니다.

이상으로 Regression 회귀 4인방 Linear, Ridge, Lasso, elasticNet에 대한 정리를 마치겠습니다.

감사합니다 🙂

F1 score은 다음과 같습니다

– 공식

F1=2∗(precision∗recall)/precision+recall

– F1 값 해석

여기서 간단하게 보면 F1 값이 높으면 precision과 recall 모두 좋은 결과를 보인다는 것을 이해할 수 있습니다. 즉 하나의 값으로 2가지 정보를 유추할 수 있는 것이죠.

그러나 F1 값이 낮으면 false positive가 문제가 있는 것인지 false negative가 문제인지는 정확히 알 수가 없기 때문에 이 경우는 디버깅이 필요합니다.

 

class sklearn.preprocessing.StandardScaler(copy=True, with_mean=True, with_std=True)에 있는 fit_transform() 메소드는 말 그대로 fit()한 다음에 transform() 하는 것입니다. 여기서 fit()이란 정규화 즉, 통계에서 정규분포를 만들게 하기 위해서 𝑥 값에서 평균을 빼고 그 값을 다시 표준편차로 나누어주는 작업을 하는데 이 작업을 하기 위해 평균 𝜇과  표준편차 𝜎를 계산하는 작업이 fit() 이고, transform()은 정규화 작업을 해주는 것입니다. (𝑥-𝜇)/𝜎 ==> 새로운 𝑥′ 생기는 것이죠

트레이닝 데이터에 대해서 fit 작업과 transform 작업을 적용해주는 것이 fit_transform이고 여기서 계산된 평균 𝜇과  표준편차 𝜎를 동일하게 테스트 데이터에 적용해서 정규화 작업을 해주는 경우는 transform()만 적용합니다.  테스트 세트에도 트레이닝 데이터에 적용되었던 동일한 평균과 표준편차를 적용하기 위해서 이전에 fit_transform()에서 계산된 값들이 저장된 상태에서 transform()에 적용되는 것입니다.

아래 출처를 따라가 보시면 fit_transform의 파라미터들을 자세히 살펴보실 수 있습니다.

https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.StandardScaler.html#sklearn.preprocessing.StandardScaler.fit_transform