04. 머신러닝 핵심 알고리즘 (2)

---

출처 : https://book.naver.com/bookdb/book_detail.nhn?bid=21488029 

공개적 빅데이터분석기사 실기

*해당 글은 학습을 목적으로 위의 도서 내용 중 일부 내용만을 요약하여 작성한 포스팅입니다.

 상세 내용 및 전체 내용 확인을 원하신다면 도서 구매를 추천드립니다.

---

 

 

투표기반 앙상블

• 투표기반 앙상블은 여러 분류기를 학습시킨 후 각 분류기의 예측 중 가장 많이 나온 범주를 선택하는 방법이다.
• 다수결의 원리와 유사하며, 보다 좋은 분류와 회귀 예측이 가능하다.
• 분류 알고리즘의 앙상블 결과는 범주를 기반으로 할 수도 있고 확률을 기반으로 할 수도 있다. 범주 기반은 Hard Learner, 확률 기반은 Soft Learner를 선택하면 된다.
• sklearn.ensemble의 VotingClassifier, VotingRegressor을 사용할 수 있으며, 주요 하이퍼파라미터로 위에서 언급한 voting 파아미터에 hard, soft를 선택할 수 있다. (분류 문제에서만 적용 가능)
• 분류의 경우 다음과 같이 구현한다.

import pandas as pd
from sklearn.model_selection import train_test_split, GridSearchCV
from sklearn.preprocessing import MinMaxScaler
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier
from sklearn.svm import SVC
from sklearn.ensemble import VotingClassifier
from sklearn.metrics import accuracy_score
import warnings

warnings.filterwarnings('ignore')

data = pd.read_csv('/breast-cancer-wisconsin.csv')

x = data[data.columns[1:10]]
y = data[['Class']]
train_x, test_x, train_y, test_y = train_test_split(x, y, stratify=y, random_state = 42)

mmScaler = MinMaxScaler()
mmScaler.fit(train_x)
train_x = mmScaler.transform(train_x)
test_x = mmScaler.transform(test_x)

# 모델1. 로지스틱 회귀 모델
param_grid = {'C': [0.01, 0.1, 1, 10]}
gSearch = GridSearchCV(LogisticRegression(), param_grid, cv=5)
gSearch.fit(train_x, train_y)

model_logistic = LogisticRegression(C=gSearch.best_params_['C'])

# 모델2. SVC
param_grid = [
              {'kernel': ['rbf'], 'C': [0.01, 0.1, 1, 10], 'gamma': [0.01, 0.1, 1, 10]},
              {'kernel': ['linear'], 'C': [0.01, 0.1, 1, 10], 'gamma': [0.01, 0.1, 1, 10]}
             ]
gSearch = GridSearchCV(SVC(), param_grid, cv=5)
gSearch.fit(train_x, train_y)

model_svc = SVC(kernel = gSearch.best_params_['kernel'], 
                C = gSearch.best_params_['C'], 
                gamma = gSearch.best_params_['gamma'])
# SVC를 SOFT VOTING 방식으로 사용하기 위해서는 probability=True 파라미터가 필요하다.
model_svc_s = SVC(kernel = gSearch.best_params_['kernel'], 
                  C = gSearch.best_params_['C'], 
                  gamma = gSearch.best_params_['gamma'], 
                  probability=True)



# 모델3. RandomForest
param_grid = {'n_estimators': [10, 30, 50], 'max_features': ['auto', 'sqrt', 'log2']}
gSearch = GridSearchCV(RandomForestClassifier(), param_grid, cv=5)
gSearch.fit(train_x, train_y)

model_random = RandomForestClassifier(n_estimators = gSearch.best_params_['n_estimators'], max_features=gSearch.best_params_['max_features'])

# 앙상블
estimators = [('lr', model_logistic), ('svc', model_svc), ('rf', model_random)]
estimators_s = [('lr', model_logistic), ('svc', model_svc_s), ('rf', model_random)]
voting_hard = VotingClassifier(estimators=estimators)
voting_soft = VotingClassifier(voting='soft', estimators=estimators_s)

for clf in (model_logistic, model_svc, model_random, voting_hard, voting_soft) :
  clf.fit(train_x, train_y)
  y_pred = clf.predict(test_x)
  print(clf.__class__.__name__, accuracy_score(test_y, y_pred))

• 회귀의 경우는 다음과 같이 사용 가능하다.

import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split, GridSearchCV
from sklearn.preprocessing import MinMaxScaler
from sklearn.linear_model import LinearRegression
from sklearn.ensemble import RandomForestRegressor, VotingRegressor
from sklearn.metrics import mean_squared_error
import warnings

warnings.filterwarnings('ignore')

data = pd.read_csv('/house_price.csv')
data.dropna(inplace=True)

x = data[data.columns[1:5]]
y = data[['house_value']]

x_train, x_test, y_train, y_test = train_test_split(x, y, random_state=42)

mmScaler = MinMaxScaler()
mmScaler.fit(x_train)
x_train = mmScaler.transform(x_train)
x_test = mmScaler.transform(x_test)

# 1. 선형 회귀
model_l = LinearRegression()

# 2. RandomForest
model_r = RandomForestRegressor()

# 3. 앙상블
model_e = VotingRegressor(estimators = [('lr', model_l), ('rf', model_r)])

for clf in (model_l, model_r, model_e) :
  clf.fit(x_train, y_train)
  y_pred = clf.predict(x_test)
  print(clf.__class__.__name__, np.sqrt(mean_squared_error(y_test, y_pred)))

 

 

 

배깅

• 배깅은 앙상블 방법 중 하나로 학습 데이터에 대해 여러 개의 부트스트랩을 생성하고 각 부트스트랩 데이터에 하나 혹은 여러 알고리즘을 학습시킨 후 산출된 결과를 토대로 투표를 통해 최종 결과를 선정한다.
• 즉 서로 다른 데이터로 학습시킨 동일 알고리즘을 앙상블하는 기법이다.
• sklearn.ensemble 내에 BaggingClassifier, BaggingRegressor를 사용할 수 있다.
• 주요 하이퍼 파라미터는 n_estimators이고, 부트스트랩 데이터셋 수를 의미하며 디폴트는 10이다.

from sklearn.svm import SVC
from sklearn.ensemble import BaggingClassifier

# 분류

data = pd.read_csv('/breast-cancer-wisconsin.csv')

x = data[data.columns[1:10]]
y = data[['Class']]
train_x, test_x, train_y, test_y = train_test_split(x, y, stratify=y, random_state = 42)

mmScaler = MinMaxScaler()
mmScaler.fit(train_x)
train_x = mmScaler.transform(train_x)
test_x = mmScaler.transform(test_x)

model = BaggingClassifier(base_estimator=SVC(), n_estimators=10, random_state=42)
model.fit(x_train, y_train)
model.score(x_test, y_test)


# 회귀

from sklearn.neighbors import KNeighborsRegressor
from sklearn.ensemble import BaggingRegressor
from sklearn.metrics import mean_squared_error

data = pd.read_csv('/house_price.csv')
data.dropna(inplace=True)

x = data[data.columns[1:5]]
y = data[['house_value']]

x_train, x_test, y_train, y_test = train_test_split(x, y, random_state=42)

mmScaler = MinMaxScaler()
mmScaler.fit(x_train)
x_train = mmScaler.transform(x_train)
x_test = mmScaler.transform(x_test)

model = BaggingRegressor(base_estimator=KNeighborsRegressor(), n_estimators=10, random_state=42)
model.fit(x_train, y_train)

print(np.sqrt(mean_squared_error(y_test, model.predict(x_test))))

 

 

부스팅

• 부스팅은 여러 개의 약한 학습기를 순차적으로 학습시켜 예측하며 잘못 예측한 데이터에 가중치를 부여하여 오류를 개선하며 학습하는 모델이다.
• 배깅이 병렬적으로 학습한다면 부스팅은 직렬적으로 학습한다.
• sklearn.ensemble 내에 존재하며, AdaBoostClassifier와 GradientBoostingClassifier, AdaBoostRegressor와 GradientBoostingRegressor을 사용할 수 있다.
• AdaBoost 계열은 base_estimators, n_estimator가 핵심 하이퍼파라미터이다.
• GradientBoosting은 학습률을 설정하고 오차를 줄이는 방향으로 학습을 설정하기에 하이퍼 파라미터 설정이 다소 복잡할 수 있다.

from sklearn.ensemble import AdaBoostClassifier, GradientBoostingClassifier

# 분류
model_a_c = AdaBoostClassifier(n_estimators=10, random_state=42)
model_g_c = GradientBoostingClassifier(n_estimators=10, learning_rate=0.1, max_depth=1, random_state=42)

model_a_c.fit(x_train_c, y_train_c)
model_g_c.fit(x_train_c, y_train_c)

print('Ada :', model_a_c.score(x_test_c, y_test_c))
print('Gra :', model_g_c.score(x_test_c, y_test_c))



from sklearn.ensemble import AdaBoostRegressor, GradientBoostingRegressor

# 회귀
model_a_r = AdaBoostRegressor(n_estimators=10, random_state=42)
model_g_r = GradientBoostingRegressor(random_state=42)

model_a_r.fit(x_train_r, y_train_r)
model_g_r.fit(x_train_r, y_train_r)

print('Ada :', np.sqrt(mean_squared_error(x_test_r, model_a_r.predict(test_r))))
print('Gra :', np.sqrt(mean_squared_error(x_test_r, model_g_r.predict(test_r))))

 

 

스태킹

• 스태킹은 여러 학습기가 예측한 예측값으로 다시 학습 데이터를 만들어 일반화된 최종 모델을 구성하는 방법이다.
• 즉 학습 데이터로 여러 모델을 만들고 해당 모델들이 예측한 데이터를 다시 학습 데이터로 사용하여 최종 모델을 만든다.
• sklearn.ensemble 내에 StackingClassifier, StackingRegressor를 사용하면 된다.

from sklearn.ensemble import RandomForestClassifier
from sklearn.svc import SVC
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import StackingClassifier


#분류
estimators = [('rf', RandomForestClassifier(n_estimators=10, random_state=42)),
              ('svc', SVC(random_state=42))]

model = StackingClassifier(estimators=estimators, final_estimator=LogisticRegression())

model.fit(x_train_c, y_train_c)

print(model.score(x_test_c, y_test_c))


from sklearn.linear_model import LinearRegression
from sklearn.neighbors import KNeighborsRegressor
from sklearn.ensemble import RandomForestRegressor
from sklearn.ensemble import StackingRegressor

#회귀
estimators = [('lr', LinearRegression()),
              ('knn', KNeighborsRegressor())]

model = StatckingRegressor(estimators=estimators, 
                           final_estimator=RandomForestRegressor(n_estimators=10, random_state=42))

model.fit(x_train_r, y_train_r)

print(model.score(x_train_r, y_train_r))