회귀 및 의사결정나무, Random Forest, Gradient Boost 모형 모델 평가하기

 

 

모델 평가¶

 

• 정확도 : 분류/ 예측 의 성능이 우수한가? (정확한가) 과대적합 확인
• 안정성/일반성 : 동일 모집단의 다른 데이터에 적용 시 안정적인 결과가 나오는가? 교차 검증(cross validation)
• 효율성 : 유사한 성능이라면 얼마나 적은 지원(자료 및 설명변수 수)을 사용하는가?

 

• 예측/회귀(prediction) - 연속(interval)
  • Linear Regression / Ridge/LASSO/Elastic Net Regression / Decision tree / Neural Network
  • 평가 방법: Residual Plot, MSE(Mean Squared Error), RMSE, MAE, MAPE, R^, adjusted R^2, AIC, BIC 등
• 분류(classification) : 범주(class
  • 주요 모델: Logistic Regression, Decision Tree, Random Forest, Gradient Boosting, KNN, Naive Bayesian, Neural Network
  • 평가 방법: Misclassification Rate(Confusion Matrix), ROC Chart & AUC, F1 점수, LIFT(향상도, %Response, %Captured Response)

 

• 모델 평가(예측 모델)
  • MSE(Mean Squared Error)
  • RMSE(Root MSE)
  • MAE(Mean Absolute Error)
  • MAPE(Mean Absolute Percentage Error)

 

패키지 불러오기¶

In [1]:

# 데이터 구성:Series, DataFrame
import pandas as pd
import numpy as np
# 데이터 시각화
import matplotlib.pyplot as plt
import matplotlib

# 데이터 분할:train, test
from sklearn.model_selection import train_test_split

# 회귀분석
import statsmodels.formula.api as smf
# Decision Tree
from sklearn.tree import DecisionTreeRegressor
# Random Forest
from sklearn.ensemble import RandomForestRegressor
# Gradient Boosting
from sklearn.ensemble import GradientBoostingRegressor
# 평가 함수
from sklearn.metrics import mean_squared_error
from sklearn.metrics import mean_absolute_error

 

평가 함수 정의¶

 

rmse, mape 는 sklearn에서 제공되지 않는 함수이기 때문

In [6]:

# RMSE:root mean squared error 함수
def root_mean_squared_error(y_true, y_pred):
    return np.sqrt(mean_squared_error(y_true, y_pred))

# MAPE:mean absolute percentage error 함수
def mean_absolute_percentage_error(y_true, y_pred):
    return np.mean(np.abs((y_true - y_pred) / y_true)) * 100

 

데이터 구성하기¶

In [2]:

df_raw = pd.read_csv(".CSV")
df_raw.head()

Out[2]:

	FAT	AGE	WEIGHT	HEIGHT	NECK	CHEST	ABDOMEN	HIP	THIGH	KNEE	ANKLE	BICEPS	FOREARM	WRIST
0	35.2	46	363.15	72.25	51.2	136.2	148.1	147.7	87.3	49.1	29.6	45.0	29.0	21.4
1	11.8	27	168.00	71.25	38.1	93.0	79.1	94.5	57.3	36.2	24.5	29.0	30.0	18.8
2	22.2	69	177.75	68.50	38.7	102.0	95.0	98.3	55.0	38.3	21.8	30.8	25.7	18.8
3	10.6	57	147.75	65.75	35.2	99.6	86.4	90.1	53.0	35.0	21.3	31.7	27.3	16.9
4	47.5	51	219.00	64.00	41.2	119.8	122.1	112.8	62.5	36.9	23.6	34.7	29.1	18.4

In [4]:

# 목표변수, 설명변수 데이터 지정
df_raw_y = df_raw["FAT"]
df_raw_x = df_raw.drop("FAT", axis = 1, inplace = False)

In [5]:

df_train_x, df_test_x, df_train_y, df_test_y = train_test_split(df_raw_x, df_raw_y
                                                                , test_size = 0.3, random_state = 1234) 
print("train data X size : {}".format(df_train_x.shape))
print("train data Y size : {}".format(df_train_y.shape))
print("test data X size : {}".format(df_test_x.shape))
print("test data Y size : {}".format(df_test_y.shape))

 

train data X size : (176, 13)
train data Y size : (176,)
test data X size : (76, 13)
test data Y size : (76,)

 

예측 모델 생성¶

 

모델의 파라미터 값은 이전에 조절해서 구했던 값을 집어넣음

In [7]:

lr_model = smf.ols(formula="FAT ~ NECK + ABDOMEN + HIP + FOREARM + WRIST", data=df_raw)
lr_result = lr_model.fit()
#print(lr_result.summary())

dt_model = DecisionTreeRegressor(random_state=1234, min_samples_leaf=8, min_samples_split=20, max_depth=4)
dt_model.fit(df_train_x, df_train_y)

rf_model = RandomForestRegressor(random_state=1234, n_estimators=100, min_samples_leaf=6, min_samples_split=14, max_depth=4)
rf_model.fit(df_train_x, df_train_y)

gb_model = GradientBoostingRegressor(random_state=1234, n_estimators=30, min_samples_leaf=11, min_samples_split=22, max_depth=4, learning_rate = 0.1)
gb_model.fit(df_train_x, df_train_y)

Out[7]:

GradientBoostingRegressor(max_depth=4, min_samples_leaf=11,
                          min_samples_split=22, n_estimators=30,
                          random_state=1234)

In [8]:

models = ["회귀분석", "의사결정나무 ", "랜덤 포레스트", "그래디언트 부스팅"]
mse, rmse, mae, mape = [], [], [], []

 

회귀분석

In [9]:

lr_y_pred = lr_result.predict(df_test_x)
mse.append(mean_squared_error(df_test_y, lr_y_pred))
rmse.append(root_mean_squared_error(df_test_y, lr_y_pred))
mae.append(mean_absolute_error(df_test_y, lr_y_pred))
mape.append(mean_absolute_percentage_error(df_test_y, lr_y_pred))

 

의사결정나무

In [10]:

dt_y_pred = dt_model.predict(df_test_x)
mse.append(mean_squared_error(df_test_y, dt_y_pred))
rmse.append(root_mean_squared_error(df_test_y, dt_y_pred))
mae.append(mean_absolute_error(df_test_y, dt_y_pred))
mape.append(mean_absolute_percentage_error(df_test_y, dt_y_pred))

 

랜덤 포레스트

In [11]:

rf_y_pred = rf_model.predict(df_test_x)
mse.append(mean_squared_error(df_test_y, rf_y_pred))
rmse.append(root_mean_squared_error(df_test_y, rf_y_pred))
mae.append(mean_absolute_error(df_test_y, rf_y_pred))
mape.append(mean_absolute_percentage_error(df_test_y, rf_y_pred))

 

그래디언 부스팅

In [12]:

gb_y_pred = gb_model.predict(df_test_x)
mse.append(mean_squared_error(df_test_y, gb_y_pred))
rmse.append(root_mean_squared_error(df_test_y, gb_y_pred))
mae.append(mean_absolute_error(df_test_y, gb_y_pred))
mape.append(mean_absolute_percentage_error(df_test_y, gb_y_pred))

In [18]:

mse

Out[18]:

[20.147912278293237,
 28.634493304123627,
 24.822829014027725,
 24.715876257051278]

In [15]:

rmse

Out[15]:

[4.488642587497164, 5.351120752153107, 4.982251400123014, 4.9715064373941305]

In [16]:

mae

Out[16]:

[3.575985188198865, 4.3936829257071555, 4.116729612141941, 4.087580962926603]

In [17]:

mape

Out[17]:

[22.999459038443856, 29.611214852193317, 25.72889647978033, 25.43899301726852]

 

시각화¶

In [13]:

matplotlib.rc('font', family='Malgun Gothic')
fig, ax = plt.subplots(2,2, figsize = (13, 10))
ax[0, 0].bar(models, mse)
ax[0, 0].set_title("mse").set_fontsize(15)

ax[0, 1].bar(models, rmse)
ax[0, 1].set_title("rmse").set_fontsize(15)

ax[1, 0].bar(models, mae)
ax[1, 0].set_title("mae").set_fontsize(15)

ax[1, 1].bar(models,mape)
ax[1, 1].set_title("mape").set_fontsize(15)

 

 

• 후진제거로 선택된 설명변수를 이용한 선형회귀모델의 정확도가 가장 높고, 반면에 의사결정나무 모델의 성능이 가장 미흡하며,
• 평가 지표별 모델의 정확도 추세는 유사하게 나타남