ch 5.7_로지스틱 회귀_ 5.8_회귀 트리 (실습)

1  5.7 로지스틱 회귀

import pandas as pd
import matplotlib.pyplot as plt
%matplotlib inline

from sklearn.datasets import load_breast_cancer
from sklearn.linear_model import LogisticRegression

import warnings
warnings.filterwarnings(action='ignore')

 

2  1. 데이터 로드

# 유방암 데이터 로드
cancer = load_breast_cancer()

from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split

# StandardScaling (평균 0, 분산 1)
scaler = StandardScaler()
data_scaled = scaler.fit_transform(cancer.data)

# train, test 데이터 나누기
X_train , X_test, y_train , y_test = train_test_split(data_scaled, cancer.target, test_size=0.3, random_state=0)

 

 

3  2. 로지스틱 회귀 학습

from sklearn.metrics import accuracy_score, roc_auc_score

# 학습 (로지스틱 회귀) 
lr_clf = LogisticRegression()
lr_clf.fit(X_train, y_train)

 

 

4  3. 예측 및 평가

# 예측
lr_preds = lr_clf.predict(X_test)

# accuracy와 roc_auc 측정
print('accuracy: {:0.3f}'.format(accuracy_score(y_test, lr_preds)))
print('roc_auc: {:0.3f}'.format(roc_auc_score(y_test , lr_preds)))


>>> 
accuracy: 0.977
roc_auc: 0.972

 

 

5  4. 그리드서치로 Logistic regression 하이퍼 파라미터 튜닝

 

# penalty : 규제 종류(L1, L2)
# C : 규제 강도 alpha의 역수 (클수록 규제 강도 크다)

from sklearn.model_selection import GridSearchCV

params = {'penalty':['l2', 'l1'],
          'C':[0.01, 0.1, 1, 5, 10]}

grid_clf = GridSearchCV(lr_clf, param_grid=params, scoring='accuracy', cv=3 )
grid_clf.fit(data_scaled, cancer.target)
print('최적 하이퍼 파라미터:{}'.format(grid_clf.best_params_))
print('최적 평균 정확도   :{:.3f}'.format(grid_clf.best_score_))                      

>>>
최적 하이퍼 파라미터:{'C': 1, 'penalty': 'l2'}
최적 평균 정확도   :0.975

 

 

 

6  5.8 트리 회귀(회귀 트리)

 

from sklearn.datasets import load_boston
from sklearn.model_selection import cross_val_score
from sklearn.ensemble import RandomForestRegressor
import pandas as pd
import numpy as np

 

7  1. 보스턴 데이터 세트 로드

 

boston = load_boston()
bostonDF = pd.DataFrame(boston.data, columns = boston.feature_names)

print(bostonDF.shape)
bostonDF.head(3)

>>> (506, 13)

 

 

# target 데이터프레임 생성
bostonDF['PRICE'] = boston.target
y_target = bostonDF['PRICE']

# feature 데이터프레임에서는 PRICE 컬럼 삭제
X_data = bostonDF.drop(['PRICE'], axis=1,inplace=False)

 

 

8  2. 학습 및 평가 : RandomForestRegressor 회귀트리 모델

 

# 학습 모델 : RandomForestRegressor
rf = RandomForestRegressor(random_state=0, n_estimators=1000)

# 학습 및 평가 (cross_val_score : MSE를 리스트 형태로 반환해줌 )
neg_mse_scores = cross_val_score(rf, X_data, y_target, scoring="neg_mean_squared_error", cv = 5)
rmse_scores  = np.sqrt(-1 * neg_mse_scores)
avg_rmse = np.mean(rmse_scores)

print(' 5 교차 검증의 개별 Negative MSE scores: ', np.round(neg_mse_scores, 2))
print(' 5 교차 검증의 개별 RMSE scores : ', np.round(rmse_scores, 2))
print(' 5 교차 검증의 평균 RMSE : {0:.3f} '.format(avg_rmse))

>>>
 5 교차 검증의 개별 Negative MSE scores:  [ -7.88 -13.14 -20.57 -46.23 -18.88]
 5 교차 검증의 개별 RMSE scores :  [2.81 3.63 4.54 6.8  4.34]
 5 교차 검증의 평균 RMSE : 4.423

 

 

9  4. 여러 트리회귀 클래스 예측 후 비교

 

from sklearn.tree import DecisionTreeRegressor       
from sklearn.ensemble import RandomForestRegressor 
from sklearn.ensemble import GradientBoostingRegressor
from xgboost import XGBRegressor
from lightgbm import LGBMRegressor

# cross_val_score로 교차검증 학습 후 평가지표로 RMSE를 알려주는 함수
def get_model_cv_prediction(model, X_data, y_target):
    neg_mse_scores = cross_val_score(model, X_data, y_target, scoring="neg_mean_squared_error", cv = 5)
    rmse_scores  = np.sqrt(-1 * neg_mse_scores)
    avg_rmse = np.mean(rmse_scores)
    
    print('##### ', model.__class__.__name__ , ' #####')
    print(' 교차 검증의 평균 RMSE : {0:.3f} '.format(avg_rmse), '\n')

 

dt_reg = DecisionTreeRegressor(random_state=0, max_depth=4)
rf_reg = RandomForestRegressor(random_state=0, n_estimators=1000)
gb_reg = GradientBoostingRegressor(random_state=0, n_estimators=1000)
xgb_reg = XGBRegressor(n_estimators=1000)
lgb_reg = LGBMRegressor(n_estimators=1000)

# 트리 기반의 회귀 모델을 반복하면서 평가 수행 
models = [dt_reg, rf_reg, gb_reg, xgb_reg, lgb_reg]

for model in models:  
    get_model_cv_prediction(model, X_data, y_target)


>>> 
#####  DecisionTreeRegressor  #####
 교차 검증의 평균 RMSE : 5.978  

#####  RandomForestRegressor  #####
 교차 검증의 평균 RMSE : 4.423  

#####  GradientBoostingRegressor  #####
 교차 검증의 평균 RMSE : 4.269  

#####  XGBRegressor  #####
 교차 검증의 평균 RMSE : 4.251  

#####  LGBMRegressor  #####
 교차 검증의 평균 RMSE : 4.646

 

-> 
디시젼트리보다는 랜덤포레스트 성능이 좋다.
제일 성능이 좋은 모델은 XGBRegressor이다.

 

10  5. 트리회귀의 피처 중요도 확인

회귀 트리는 선형 회귀의 회귀 계수 대신, feature_importances_로 피처의 중요도를 알 수 있습니다.

 

import seaborn as sns
%matplotlib inline

# 학습 모델
rf_reg = RandomForestRegressor(n_estimators=1000)

# 앞 예제에서 만들어진 X_data, y_target 데이터 셋을 적용하여 학습합니다.
rf_reg.fit(X_data, y_target)

# feature_importances_ 메소드로 피처 중요도 확인
feature_series = pd.Series(data=rf_reg.feature_importances_, index=X_data.columns )
feature_series

>>>
CRIM       0.039939
ZN         0.001066
INDUS      0.006121
CHAS       0.000842
NOX        0.022241
RM         0.431967
AGE        0.013356
DIS        0.064915
RAD        0.003572
TAX        0.014333
PTRATIO    0.017014
B          0.011596
LSTAT      0.373038
dtype: float64

 

 

feature_series = feature_series.sort_values(ascending=False)
sns.barplot(x= feature_series, y=feature_series.index)

 

 

11  6. 트리회귀의 max_depth에 따른 오버피팅 확인해보기

트리회귀의 회귀 예측선을 그려보고 max_depth에 따른 오버피팅을 확인해보자

 

boston = load_boston()
bostonDF = pd.DataFrame(boston.data, columns = boston.feature_names)
bostonDF['PRICE'] = boston.target

print(bostonDF.shape)
bostonDF.head(3)

 

 

import matplotlib.pyplot as plt
%matplotlib inline

# 한 개의 피처(RM)와 타겟값 선정
# x축:RM, y축:PRICE
bostonDF_sample = bostonDF[['RM','PRICE']]

# 데이터 중 100개만 샘플링
bostonDF_sample = bostonDF_sample.sample(n=100, random_state=0)

print(bostonDF_sample.shape)
plt.figure()
plt.scatter(bostonDF_sample.RM, bostonDF_sample.PRICE, c="darkorange")

 

 

import numpy as np
from sklearn.linear_model import LinearRegression
from sklearn.tree import DecisionTreeRegressor

# 모델 : 선형회귀와 트리회귀 
lr_reg = LinearRegression()
rf_reg2 = DecisionTreeRegressor(max_depth=2)
rf_reg7 = DecisionTreeRegressor(max_depth=7)

# x축 - 테스트 데이터를 4.5 ~ 8.5 범위, 100개 생성. 
X_test = np.arange(4.5, 8.5, 0.04).reshape(-1, 1)

# 피처는 RM만, 타겟값 PRICE 추출
X_feature = bostonDF_sample['RM'].values.reshape(-1,1)
y_target = bostonDF_sample['PRICE'].values.reshape(-1,1)

# 학습
lr_reg.fit(X_feature, y_target)
rf_reg2.fit(X_feature, y_target)
rf_reg7.fit(X_feature, y_target)

# 예측
pred_lr = lr_reg.predict(X_test)
pred_rf2 = rf_reg2.predict(X_test)
pred_rf7 = rf_reg7.predict(X_test)

 

# 선형회귀와 트리회귀의 회귀 예측선 그리기 (X축 값 범위 4.5 ~ 8.5)

fig , (ax1, ax2, ax3) = plt.subplots(figsize=(14,4), ncols=3)

# 선형회귀
ax1.set_title('Linear Regression')
ax1.scatter(bostonDF_sample.RM, bostonDF_sample.PRICE, c="darkorange")
ax1.plot(X_test, pred_lr,label="linear", linewidth=2 )

# 트리회귀 max_depth=2
ax2.set_title('Decision Tree Regression: \n max_depth=2')
ax2.scatter(bostonDF_sample.RM, bostonDF_sample.PRICE, c="darkorange")
ax2.plot(X_test, pred_rf2, label="max_depth:3", linewidth=2)

# 트리회귀 max_depth=7 -> overfitting!
ax3.set_title('Decision Tree Regression: \n max_depth=7')
ax3.scatter(bostonDF_sample.RM, bostonDF_sample.PRICE, c="darkorange")
ax3.plot(X_test, pred_rf7, label="max_depth:7", linewidth=2)