[ECC DS 1주차] Introduction to Ensembling/Stacking in Python

0. Introduction

• 기본 학습 모델들을 앙상블하는 방법에 대해 설명(특히 stacking)

• 몇 가지 기본 분류기의 예측을 1차 수준(베이스)으로 사용한 다음 2차 수준에서 다른 모델을 사용하여 이전 1차 수준 예측의 출력을 예측

### Import libraries
import pandas as pd
import numpy as np
import re
import sklearn
import xgboost as xgb
import seaborn as sns
import matplotlib.pyplot as plt
%matplotlib inline

import plotly.offline as py
import plotly.io as pio
py.init_notebook_mode(connected=True)
import plotly.graph_objs as go
import plotly.tools as tls

import warnings
warnings.filterwarnings('ignore')

### stacking에 사용될 base model 5가지
from sklearn.ensemble import (RandomForestClassifier, AdaBoostClassifier, 
                              GradientBoostingClassifier, ExtraTreesClassifier)
from sklearn.svm import SVC
from sklearn.model_selection import KFold # sklearn version에 맞게 모듈 변경

1. 변수 파악, 가공, 전처리

• 데이터 탐색 -> 가능한 가공 방법 찾기

• 모든 범주형 feature들을 수치적으로 변환(encoding)

### Data Loading
train = pd.read_csv('/content/drive/MyDrive/Colab Notebooks/ECC 48기 데과B/1주차/data/train.csv')
test = pd.read_csv('/content/drive/MyDrive/Colab Notebooks/ECC 48기 데과B/1주차/data/test.csv')

# 쉬운 접근을 위헤 PassengerId만 따로 저장하기
PassengerId = test['PassengerId']

train.head(3)

	PassengerId	Survived	Pclass	Name	Sex	Age	SibSp	Parch	Ticket	Fare	Cabin	Embarked
0	1	0	3	Braund, Mr. Owen Harris	male	22.0	1	0	A/5 21171	7.2500	NaN	S
1	2	1	1	Cumings, Mrs. John Bradley (Florence Briggs Th...	female	38.0	1	0	PC 17599	71.2833	C85	C
2	3	1	3	Heikkinen, Miss. Laina	female	26.0	0	0	STON/O2. 3101282	7.9250	NaN	S

1-1. 특성 공학(Feature Engineering)

### 전체 데이터
full_data = [train, test]

### 새로운 변수 생성

# 이름 길이
train['Name_length'] = train['Name'].apply(len)
test['Name_length'] = test['Name'].apply(len)

# cabin 유무
train['Has_Cabin'] = train["Cabin"].apply(lambda x: 0 if type(x) == float else 1)
test['Has_Cabin'] = test["Cabin"].apply(lambda x: 0 if type(x) == float else 1)

# FamilySize = SibSp + Parch
for dataset in full_data:
    dataset['FamilySize'] = dataset['SibSp'] + dataset['Parch'] + 1

# 혼자인 승객
for dataset in full_data:
    dataset['IsAlone'] = 0
    dataset.loc[dataset['FamilySize'] == 1, 'IsAlone'] = 1

# CategoricalAge: 나이대 구분
for dataset in full_data:
    age_avg = dataset['Age'].mean()
    age_std = dataset['Age'].std()
    age_null_count = dataset['Age'].isnull().sum()
    age_null_random_list = np.random.randint(age_avg - age_std, age_avg + age_std, size = age_null_count) # 랜덤한 나이 삽입
    dataset['Age'][np.isnan(dataset['Age'])] = age_null_random_list
    dataset['Age'] = dataset['Age'].astype(int)
train['CategoricalAge'] = pd.cut(train['Age'], 5)

# Title
# 승객 이름에서 title만 뽑아내는 함수
def get_title(name):
    title_search = re.search(' ([A-Za-z]+)\.', name)
    if title_search: # title이 있다면
        return title_search.group(1)
    return ""

for dataset in full_data:
    dataset['Title'] = dataset['Name'].apply(get_title)

# 흔하지 않은 title은 'Rare'로 합침
for dataset in full_data:
    dataset['Title'] = dataset['Title'].replace(['Lady', 'Countess','Capt', 'Col','Don', 
                                                 'Dr', 'Major', 'Rev', 'Sir', 'Jonkheer', 'Dona'], 'Rare')
    dataset['Title'] = dataset['Title'].replace('Mlle', 'Miss')
    dataset['Title'] = dataset['Title'].replace('Ms', 'Miss')
    dataset['Title'] = dataset['Title'].replace('Mme', 'Mrs')

### 결측치 제거

# Embarked: 'S'로 대체
for dataset in full_data:
    dataset['Embarked'] = dataset['Embarked'].fillna('S')

# Fare: 중간값으로 대체, 4개의 범주로 구분
for dataset in full_data:
    dataset['Fare'] = dataset['Fare'].fillna(train['Fare'].median())
train['CategoricalFare'] = pd.qcut(train['Fare'], 4)

### 범주형 변수 -> 수치형 변수
# map 함수 활용

for dataset in full_data:
    # Sex
    dataset['Sex'] = dataset['Sex'].map( {'female': 0, 'male': 1} ).astype(int)
    
    # Title
    title_mapping = {"Mr": 1, "Miss": 2, "Mrs": 3, "Master": 4, "Rare": 5}
    dataset['Title'] = dataset['Title'].map(title_mapping)
    dataset['Title'] = dataset['Title'].fillna(0)
    
    # Embarked
    dataset['Embarked'] = dataset['Embarked'].map( {'S': 0, 'C': 1, 'Q': 2} ).astype(int)
    
    # Fare
    dataset.loc[ dataset['Fare'] <= 7.91, 'Fare'] = 0
    dataset.loc[(dataset['Fare'] > 7.91) & (dataset['Fare'] <= 14.454), 'Fare'] = 1
    dataset.loc[(dataset['Fare'] > 14.454) & (dataset['Fare'] <= 31), 'Fare'] = 2
    dataset.loc[ dataset['Fare'] > 31, 'Fare'] = 3
    dataset['Fare'] = dataset['Fare'].astype(int)
    
    # Age
    dataset.loc[ dataset['Age'] <= 16, 'Age'] = 0
    dataset.loc[(dataset['Age'] > 16) & (dataset['Age'] <= 32), 'Age'] = 1
    dataset.loc[(dataset['Age'] > 32) & (dataset['Age'] <= 48), 'Age'] = 2
    dataset.loc[(dataset['Age'] > 48) & (dataset['Age'] <= 64), 'Age'] = 3
    dataset.loc[ dataset['Age'] > 64, 'Age'] = 4

### 변수 선택

drop_elements = ['PassengerId', 'Name', 'Ticket', 'Cabin', 'SibSp']

train = train.drop(drop_elements, axis = 1)
train = train.drop(['CategoricalAge', 'CategoricalFare'], axis = 1)

test  = test.drop(drop_elements, axis = 1)

• feature들이 모두 숫자형

  • 기계학습에 적합한 형식

1-2. 시각화

### 데이터 확인

train.head(3)

	Survived	Pclass	Sex	Age	Parch	Fare	Embarked	Name_length	Has_Cabin	FamilySize	IsAlone	Title
0	0	3	1	1	0	0	0	23	0	2	0	1
1	1	1	0	2	0	3	1	51	1	2	0	3
2	1	3	0	1	0	1	0	22	0	1	1	2

### 상관계수(피어쓴 상관계수) 시각화

colormap = plt.cm.RdBu
plt.figure(figsize = (14,12))
plt.title('Pearson Correlation of Features', y = 1.05, size = 15)
sns.heatmap(train.astype(float).corr(),linewidths=0.1,vmax=1.0, 
            square=True, cmap=colormap, linecolor='white', annot=True)

<Axes: title={'center': 'Pearson Correlation of Features'}>

• 강한 상관관계를 가지는 feature가 많지는 않음

  • train set에 중복되거나 불필요한 데이터가 많지는 않다는 것을 의미

  • 각 feature들이 고유한 정보를 가지고 있음

• FamilySize 변수와 Parch 변수 간의 상관계수가 상당히 높음

  • 일단은 모두 분석에 활용

### pairplot
# 한 feature에서 다른 feature로의 데이터 분포를 관찰
g = sns.pairplot(train[[u'Survived', u'Pclass', u'Sex', u'Age', u'Parch', 
                        u'Fare', u'Embarked',u'FamilySize', u'Title']], 
                 hue='Survived', palette = 'seismic',size = 1.2, 
                 diag_kind = 'kde',diag_kws=dict(shade=True),plot_kws=dict(s=10) )
g.set(xticklabels=[])

<seaborn.axisgrid.PairGrid at 0x7f5b5cf21fa0>

2. 앙상블 &스태킹 모델들

2-1. Python Class 활용

• 파이썬의 클래스를 사용하여 편의성 증대

• 클래스:

  • 객체를 생성하기 위한 코드/프로그램을 확장하고, 해당 클래스에 특정한 기능과 방법을 구현

  • 동일한 방법에 대한 중복성 제거

• SklearnHelper 클래스를 작성

  • 모든 Sklearn 분류기에 공통된 내장 방법(훈련, 예측, 적합 등)을 확장 가능

# parameter 정의
ntrain = train.shape[0]
ntest = test.shape[0]
SEED = 0 # for 재생산
NFOLDS = 5 # 교차 검증 횟수
kf = KFold(n_splits = NFOLDS, shuffle = True, random_state = SEED)

# Sklearn 분류기를 확장하기 위한 클래스
class SklearnHelper(object):
    # 생성자(클래스 객체 초기화)
    def __init__(self, clf, seed=0, params=None):
        params['random_state'] = seed
        self.clf = clf(**params)
    # 학습
    def train(self, x_train, y_train):
        self.clf.fit(x_train, y_train)
    # 예측
    def predict(self, x):
        return self.clf.predict(x)
    # 적합
    def fit(self,x,y):
        return self.clf.fit(x,y)
    # 변수 중요도
    def feature_importances(self,x,y):
        print(self.clf.fit(x,y).feature_importances_)

2-2. Out of Fold 예측

• 스태킹은 기본 분류기의 예측(첫번째 수준에서의 예측)을 두 번째 수준 모델에서 학습을 위한 입력으로 사용

• 하지만 전체 훈련 데이터에 대한 기본 모델을 단순히 훈련시키고, 전체 테스트 세트에 대한 예측을 생성한 다음 2단계 훈련을 위해 이를 출력할 수는 없음

  • 기본 모형 예측이 이미 검정 집합을 보았기 때문에 과대 적합될(overfitting) 위험이 있음

---

➕ (설명 추가) KFold의 CV와 OOF

• KFold CV: 교차 검증의 한 방법(방법론적 관점)

• OOF: KFold에서 각 모델의 output를 앙상블하여 더 나은 예측을 얻는 방법(예측 기법)

### OOF를 위한 함수

def get_oof(clf, x_train, y_train, x_test):
    oof_train = np.zeros((ntrain,)) # null vector
    oof_test = np.zeros((ntest,))
    oof_test_skf = np.empty((NFOLDS, ntest))

    # 각 시도마다
    for i, (train_index, test_index) in enumerate(kf.split(train)):
        ### train 데이터 분할
        x_tr = x_train[train_index] # X_train
        y_tr = y_train[train_index] # y_train
        x_te = x_train[test_index] # X_valid

        clf.train(x_tr, y_tr) 

        oof_train[test_index] = clf.predict(x_te) 
        oof_test_skf[i, :] = clf.predict(x_test)

    oof_test[:] = oof_test_skf.mean(axis=0)
    
    return oof_train.reshape(-1, 1), oof_test.reshape(-1, 1)

3. First-level 모델 생성하기

• 활용 모델들

  • RandomForestClassifier

  • ExtraTreesClassifier

  • AdaBoost

  • GradientBoostingClassifier

  • Support Vector Machine(SVM)

3-1. Parameters

• n_jobs:

  • 훈련 프로세스에 사용되는 코어 수입니다

  • -1로 설정하면 모든 코어가 사용됩니다.

• n_estimators:

  • 학습 모델의 분류 트리 수

  • 기본값 당 10개로 설정

• max_depth:

  • 트리의 최대 깊이 또는 노드를 확장할 양

  • 너무 높게 설정하면 나무를 너무 깊게 키울 수 있으므로 과적합 위험이 있음

• verbose:

  • 학습 프로세스 중에 텍스트를 출력할지 여부를 제어

  • 값이 0이면 모든 텍스트가 억제

  • 값이 3이면 모든 반복에서 트리 학습 프로세스가 출력됨

### Parameter 정의

# RandomForest parameters
rf_params = {
    'n_jobs': -1,
    'n_estimators': 500,
     'warm_start': True, 
     #'max_features': 0.2,
    'max_depth': 6,
    'min_samples_leaf': 2,
    'max_features' : 'sqrt',
    'verbose': 0
}

# ExtraTrees Parameters
et_params = {
    'n_jobs': -1,
    'n_estimators':500,
    #'max_features': 0.5,
    'max_depth': 8,
    'min_samples_leaf': 2,
    'verbose': 0
}

# AdaBoost parameters
ada_params = {
    'n_estimators': 500,
    'learning_rate' : 0.75
}

# GradientBoosting parameters
gb_params = {
    'n_estimators': 500,
     #'max_features': 0.2,
    'max_depth': 5,
    'min_samples_leaf': 2,
    'verbose': 0
}

# Support Vector Classifier parameters 
svc_params = {
    'kernel' : 'linear',
    'C' : 0.025
}

3-2. 모델 객체 생성하기

• SKlearnHelper 클래스 활용

rf = SklearnHelper(clf = RandomForestClassifier, seed=SEED, params=rf_params)
et = SklearnHelper(clf = ExtraTreesClassifier, seed=SEED, params=et_params)
ada = SklearnHelper(clf = AdaBoostClassifier, seed=SEED, params=ada_params)
gb = SklearnHelper(clf = GradientBoostingClassifier, seed=SEED, params=gb_params)
svc = SklearnHelper(clf = SVC, seed=SEED, params=svc_params)

3-3. Train/ Test set 준비

y_train = train['Survived'].ravel()
train = train.drop(['Survived'], axis=1)
x_train = train.values # Creates an array of the train data
x_test = test.values # Creats an array of the test data

np.ravel(a, order = 'C)

• 연속적인 flatten된 배열 반환

3-4. First-level 예측 수행

• 이후 새로운 feature로 사용됨

et_oof_train, et_oof_test = get_oof(et, x_train, y_train, x_test) # Extra Trees
rf_oof_train, rf_oof_test = get_oof(rf,x_train, y_train, x_test) # Random Forest
ada_oof_train, ada_oof_test = get_oof(ada, x_train, y_train, x_test) # AdaBoost 
gb_oof_train, gb_oof_test = get_oof(gb,x_train, y_train, x_test) # Gradient Boost
svc_oof_train, svc_oof_test = get_oof(svc,x_train, y_train, x_test) # Support Vector Classifier

print("Training is complete")

Training is complete

3-5. Feature 중요도

• sklearn 문서에 따르면 대부분의 분류기는 분류기.feature_importance속성을 포함하고 있음

  • feature 중요도 반환

• 각각의 분류기로부터 생성된 feature들의 중요도 파악하기

■ 각 분류기의 feature importance

rf_feature = rf.feature_importances(x_train,y_train)
print()

et_feature = et.feature_importances(x_train, y_train)
print()

ada_feature = ada.feature_importances(x_train, y_train)
print()

gb_feature = gb.feature_importances(x_train,y_train)
print()

[0.10479793 0.20555629 0.03619519 0.0206513  0.0474984  0.02867349
 0.12913927 0.04875588 0.07241203 0.01115511 0.29516512]

[0.11750552 0.38233278 0.02881993 0.01696399 0.05547146 0.02834788
 0.04725486 0.08408039 0.04599613 0.02178079 0.17144627]

[0.028 0.01  0.018 0.068 0.038 0.01  0.692 0.012 0.056 0.    0.068]

[0.0893909  0.01072666 0.05164544 0.01271789 0.04953828 0.02331858
 0.17598644 0.03803139 0.1119689  0.00617294 0.43050258]

### 해당 속성값을 저장

rf_features = [0.10474135,  0.21837029,  0.04432652,  0.02249159,  0.05432591,  0.02854371
  ,0.07570305,  0.01088129 , 0.24247496,  0.13685733 , 0.06128402]
et_features = [ 0.12165657,  0.37098307  ,0.03129623 , 0.01591611 , 0.05525811 , 0.028157
  ,0.04589793 , 0.02030357 , 0.17289562 , 0.04853517,  0.08910063]
ada_features = [0.028 ,   0.008  ,      0.012   ,     0.05866667,   0.032 ,       0.008
  ,0.04666667 ,  0.     ,      0.05733333,   0.73866667,   0.01066667]
gb_features = [ 0.06796144 , 0.03889349 , 0.07237845 , 0.02628645 , 0.11194395,  0.04778854
  ,0.05965792 , 0.02774745,  0.07462718,  0.4593142 ,  0.01340093]

### 시각화를 위해 dataframe 생성

cols = train.columns.values # 컬럼명 지정

feature_dataframe = pd.DataFrame({
    'features': cols,
    'Random Forest feature importances': rf_features,
    'Extra Trees  feature importances': et_features,
    'AdaBoost feature importances': ada_features,
    'Gradient Boost feature importances': gb_features
})

### Plotly를 통해 interactive한 plot 보기
# Scatter plot 

### RandomForest
trace = go.Scatter(
    y = feature_dataframe['Random Forest feature importances'].values,
    x = feature_dataframe['features'].values,
    mode = 'markers',
    marker = dict(
        sizemode = 'diameter',
        sizeref = 1,
        size = 25,
        # size= feature_dataframe['AdaBoost feature importances'].values,
        #color = np.random.randn(500), #set color equal to a variable
        color = feature_dataframe['Random Forest feature importances'].values,
        colorscale = 'Portland',
        showscale = True
    ),
    text = feature_dataframe['features'].values
)
data = [trace]

layout = go.Layout(
    autosize =  True,
    title = 'Random Forest Feature Importance',
    hovermode = 'closest',
#     xaxis= dict(
#         title= 'Pop',
#         ticklen= 5,
#         zeroline= False,
#         gridwidth= 2,
#     ),
    yaxis = dict(
        title= 'Feature Importance',
        ticklen= 5,
        gridwidth= 2
    ),
    showlegend= False
)
fig = go.Figure(data=data, layout=layout)
# py.iplot(fig,filename='scatter2010')
pio.write_html(fig,file = 'rf.html',auto_open = True)
fig.show(renderer='colab') # <-- 코랩에서 보이게 하려면 해당 명령어를 추가해 주어야 함

### ExtraTreeClassifier
trace = go.Scatter(
    y = feature_dataframe['Extra Trees  feature importances'].values,
    x = feature_dataframe['features'].values,
    mode='markers',
    marker=dict(
        sizemode = 'diameter',
        sizeref = 1,
        size = 25,
        # size= feature_dataframe['AdaBoost feature importances'].values,
        #color = np.random.randn(500), #set color equal to a variable
        color = feature_dataframe['Extra Trees  feature importances'].values,
        colorscale='Portland',
        showscale=True
    ),
    text = feature_dataframe['features'].values
)
data = [trace]

layout= go.Layout(
    autosize= True,
    title= 'Extra Trees Feature Importance',
    hovermode= 'closest',
#     xaxis= dict(
#         title= 'Pop',
#         ticklen= 5,
#         zeroline= False,
#         gridwidth= 2,
#     ),
    yaxis=dict(
        title= 'Feature Importance',
        ticklen= 5,
        gridwidth= 2
    ),
    showlegend= False
)
fig = go.Figure(data=data, layout=layout)
# py.iplot(fig,filename='scatter2010')
pio.write_html(fig,file = 'et.html',auto_open = True)
fig.show(renderer='colab') # <-- 코랩에서 보이게 하려면 해당 명령어를 추가해 주어야 함

### AdaBoost
trace = go.Scatter(
    y = feature_dataframe['AdaBoost feature importances'].values,
    x = feature_dataframe['features'].values,
    mode = 'markers',
    marker=dict(
        sizemode = 'diameter',
        sizeref = 1,
        size = 25,
        # size= feature_dataframe['AdaBoost feature importances'].values,
        #color = np.random.randn(500), #set color equal to a variable
        color = feature_dataframe['AdaBoost feature importances'].values,
        colorscale='Portland',
        showscale=True
    ),
    text = feature_dataframe['features'].values
)
data = [trace]

layout= go.Layout(
    autosize= True,
    title= 'AdaBoost Feature Importance',
    hovermode= 'closest',
#     xaxis= dict(
#         title= 'Pop',
#         ticklen= 5,
#         zeroline= False,
#         gridwidth= 2,
#     ),
    yaxis=dict(
        title= 'Feature Importance',
        ticklen= 5,
        gridwidth= 2
    ),
    showlegend= False
)
fig = go.Figure(data=data, layout=layout)
# py.iplot(fig,filename='scatter2010')
pio.write_html(fig,file = 'ada.html',auto_open = True)
fig.show(renderer='colab') # <-- 코랩에서 보이게 하려면 해당 명령어를 추가해 주어야 함

### GradientBoosting
trace = go.Scatter(
    y = feature_dataframe['Gradient Boost feature importances'].values,
    x = feature_dataframe['features'].values,
    mode='markers',
    marker=dict(
        sizemode = 'diameter',
        sizeref = 1,
        size = 25,
#       size= feature_dataframe['AdaBoost feature importances'].values,
        #color = np.random.randn(500), #set color equal to a variable
        color = feature_dataframe['Gradient Boost feature importances'].values,
        colorscale='Portland',
        showscale=True
    ),
    text = feature_dataframe['features'].values
)
data = [trace]

layout= go.Layout(
    autosize= True,
    title= 'Gradient Boosting Feature Importance',
    hovermode= 'closest',
#     xaxis= dict(
#         title= 'Pop',
#         ticklen= 5,
#         zeroline= False,
#         gridwidth= 2,
#     ),
    yaxis=dict(
        title= 'Feature Importance',
        ticklen= 5,
        gridwidth= 2
    ),
    showlegend= False
)
fig = go.Figure(data=data, layout=layout)
# py.iplot(fig,filename='scatter2010')
pio.write_html(fig,file = 'gb.html',auto_open = True)
fig.show(renderer='colab') # <-- 코랩에서 보이게 하려면 해당 명령어를 추가해 주어야 함

■ 모든 feature 중요도의 평균 계산

feature_dataframe['mean'] = feature_dataframe.mean(axis= 1) 
# axis=1: 열 방향 --> 각 feature에 대해 각각의 행에 있는 값들을 가져와 평균

feature_dataframe.head(3)

	features	Random Forest feature importances	Extra Trees feature importances	AdaBoost feature importances	Gradient Boost feature importances	mean
0	Pclass	0.104741	0.121657	0.028	0.067961	0.080590
1	Sex	0.218370	0.370983	0.008	0.038893	0.159062
2	Age	0.044327	0.031296	0.012	0.072378	0.040000

### 막대 그래프로 시각화

y = feature_dataframe['mean'].values
x = feature_dataframe['features'].values

data = [go.Bar(
            x = x,
            y = y,
            width = 0.5,
            marker = dict(
                color = feature_dataframe['mean'].values,
              colorscale='Portland',
              showscale=True,
              reversescale = False
            ),
            opacity=0.6
        )]

layout = go.Layout(
    autosize = True,
    title= 'Barplots of Mean Feature Importance',
    hovermode= 'closest',
#     xaxis= dict(
#         title= 'Pop',
#         ticklen= 5,
#         zeroline= False,
#         gridwidth= 2,
#     ),
    yaxis = dict(
        title= 'Feature Importance',
        ticklen= 5,
        gridwidth= 2
    ),
    showlegend = False
)
fig = go.Figure(data=data, layout=layout)
# py.iplot(fig,filename='scatter2010')
pio.write_html(fig,file = 'barplot.html',auto_open = True)
fig.show(renderer='colab') # <-- 코랩에서 보이게 하려면 해당 명령어를 추가해 주어야 함

4. Second-level 예측 수행

⭐ First-level의 출력을 새로운 feature로

• first - level 예측을 다음 분류기의 훈련 데이터로 사용될 수 있도록 새로운 feature 세트를 구축

  • 이전 분류기의 first-level 예측을 새로운 열로 가지고, 다음 분류기를 훈련

base_predictions_train = pd.DataFrame({
    'RandomForest': rf_oof_train.ravel(),
    'ExtraTrees': et_oof_train.ravel(),
    'AdaBoost': ada_oof_train.ravel(),
    'GradientBoost': gb_oof_train.ravel()
    })

base_predictions_train.head()

	RandomForest	ExtraTrees	AdaBoost	GradientBoost
0	0.0	0.0	0.0	0.0
1	1.0	1.0	1.0	1.0
2	1.0	0.0	1.0	1.0
3	1.0	1.0	1.0	1.0
4	0.0	0.0	0.0	0.0

4-1. Second-level 훈련 set의 상관계수 heatmap

data = [
    go.Heatmap(
        z = base_predictions_train.astype(float).corr().values ,
        x = base_predictions_train.columns.values,
        y = base_predictions_train.columns.values,
        colorscale='Viridis',
        showscale=True,
        reversescale = True
    )
]

layout = go.Layout(
    autosize = True,
    title= 'Correlation Heatmap of the Second Level Training set',
    hovermode= 'closest',
#     xaxis= dict(
#         title= 'Pop',
#         ticklen= 5,
#         zeroline= False,
#         gridwidth= 2,
#     ),
    # yaxis = dict(
    #     title= 'Feature Importance',
    #     ticklen= 5,
    #     gridwidth= 2
    # ),
    # showlegend = False
)
fig = go.Figure(data=data, layout=layout)
# py.iplot(data, filename='labelled-heatmap')
pio.write_html(fig,file = 'heatmap.html',auto_open = True)
fig.show(renderer='colab') # <-- 코랩에서 보이게 하려면 해당 명령어를 추가해 주어야 함

• feature들 간의 상관도가 낮을수록 더 좋은 점수를 도출하는 경향이 있다.

x_train = np.concatenate(( et_oof_train, rf_oof_train, ada_oof_train, 
                          gb_oof_train, svc_oof_train), axis=1)
x_test = np.concatenate(( et_oof_test, rf_oof_test, ada_oof_test, 
                         gb_oof_test, svc_oof_test), axis=1)

• first-level 훈련과 테스트 예측값들을 x_train과 x_test로 저장

  • 2단계 학습 모델에 적합 가능

4-2. XGBoost를 통한 second-level 학습

• XGBoost:

  • 대규모 부스트 트리 알고리즘을 최적화하기 위해 만들어짐

gbm = xgb.XGBClassifier(
    #learning_rate = 0.02,
    n_estimators= 2000,
    max_depth= 4,
    min_child_weight= 2,
    #gamma=1,
    gamma=0.9,                        
    subsample=0.8,
    colsample_bytree=0.8,
    objective= 'binary:logistic',
    nthread= -1,
    scale_pos_weight=1).fit(x_train, y_train)

predictions = gbm.predict(x_test)

📌 XGBoost의 parameters

• max_depth:

  • 트리를 얼마나 깊게 키우고 싶은지

  • 값을 너무 높게 설정하면 과적합의 위험이 발생할 수 있음

• gamma:

  • 트리의 리프 노드에서 추가적인 파티션을 만드는 데 필요한 최소한의 loss

  • 알고리즘이 클수록 더 보수적임

• eta:

  • 과적합을 방지하기 위해 각 부스팅 단계에서 사용되는 단계 크기 수축

5. Submission

• 대회 제출을 위한 최종 예측 수행

StackingSubmission = pd.DataFrame({
    'PassengerId': PassengerId,
    'Survived': predictions })

StackingSubmission.to_csv("StackingSubmission.csv", index = False)

6. Conclusion

• 추가적으로 아래의 방법들을 시도해 볼 수 있음

  • 최적의 매개변수 값을 찾기 위해 모델을 훈련하는 데 적합한 교차 검증 전략 구현

  • feature들이 서로 uncorrelated 할수록 최종 점수가 좋음

📚Reference

• Scikit-learn API

• 기술블로그_OOF