[ECC DS 1주차] Titanic Top 4% with ensemble modeling

1.Introduction

### Import Libraries

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
%matplotlib inline

from collections import Counter

from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier, GradientBoostingClassifier, ExtraTreesClassifier, VotingClassifier
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
from sklearn.linear_model import LogisticRegression
from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.neural_network import MLPClassifier
from sklearn.svm import SVC
from sklearn.model_selection import GridSearchCV, cross_val_score, StratifiedKFold, learning_curve

### seaborn plot 기본 설정
sns.set(style = 'white', context = 'notebook', palette = 'deep')

2. 데이터 로딩/ 확인

2-1. 데이터 불러오기

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")
IDtest = test["PassengerId"]

train.head()

	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
3	4	1	1	Futrelle, Mrs. Jacques Heath (Lily May Peel)	female	35.0	1	0	113803	53.1000	C123	S
4	5	0	3	Allen, Mr. William Henry	male	35.0	0	0	373450	8.0500	NaN	S

test.head()

	PassengerId	Pclass	Name	Sex	Age	SibSp	Parch	Ticket	Fare	Cabin	Embarked
0	892	3	Kelly, Mr. James	male	34.5	0	0	330911	7.8292	NaN	Q
1	893	3	Wilkes, Mrs. James (Ellen Needs)	female	47.0	1	0	363272	7.0000	NaN	S
2	894	2	Myles, Mr. Thomas Francis	male	62.0	0	0	240276	9.6875	NaN	Q
3	895	3	Wirz, Mr. Albert	male	27.0	0	0	315154	8.6625	NaN	S
4	896	3	Hirvonen, Mrs. Alexander (Helga E Lindqvist)	female	22.0	1	1	3101298	12.2875	NaN	S

2-2. 이상치(outlier) 탐지

• IQR(사분위 범위) 방법

• Tukey Method

• IQR = Q3(75%) - Q1(25%)

• [Q1 - 1.5 * IQR, Q3 + 1.5 * IQR] 범위를 벗어나는 데이터 포인트를 이상치로 간주

### 이상치 탐지를 위한 함수

def detect_outliers(df,n,features):
    """
    피쳐의 데이터 프레임을 가져와서 Tukey 방법에 따라 
    n개 이상의 이상치를 포함하는 관측치에 해당하는 인덱스 목록을 반환
    """
    outlier_indices = [ ] # 이상치를 가지는 feature들을 저장
    for col in features: # 각 feature마다
        Q1 = np.percentile(df[col], 25)
        Q3 = np.percentile(df[col],75)
        
        # Interquartile range (IQR)
        IQR = Q3 - Q1
        
        outlier_step = 1.5 * IQR
        
        # 이상치 탐지
        outlier_list_col = df[(df[col] < Q1 - outlier_step) | (df[col] > Q3 + outlier_step )].index
        outlier_indices.extend(outlier_list_col)
        
    # 두 개 이상의 이상치를 포함하는 관측치 선택
    outlier_indices = Counter(outlier_indices)        
    multiple_outliers = list( k for k, v in outlier_indices.items() if v > n )
    
    return multiple_outliers   

# 수치형 변수들(Age, SibSp, Parch, Fare)에서 이상치 탐지

Outliers_to_drop = detect_outliers(train,2,["Age","SibSp","Parch","Fare"])

• 이상치는 예측에 극적인 영향을 미칠 수 있음 (특히 회귀 문제)

  • 이에 대한 전처리

• Tukey 방법을 활용하여 이상치 탐지

• 수치형 변수(Age, SibSp, Sarch and Fare)에서 이상치를 탐지

  • 최소 두 개의 돌출된 숫자 값을 이상치를 가진 행으로 간주

# 이상치가 있는 행 표시

train.loc[Outliers_to_drop]

	PassengerId	Survived	Pclass	Name	Sex	Age	SibSp	Parch	Ticket	Fare	Cabin	Embarked
27	28	0	1	Fortune, Mr. Charles Alexander	male	19.0	3	2	19950	263.00	C23 C25 C27	S
88	89	1	1	Fortune, Miss. Mabel Helen	female	23.0	3	2	19950	263.00	C23 C25 C27	S
159	160	0	3	Sage, Master. Thomas Henry	male	NaN	8	2	CA. 2343	69.55	NaN	S
180	181	0	3	Sage, Miss. Constance Gladys	female	NaN	8	2	CA. 2343	69.55	NaN	S
201	202	0	3	Sage, Mr. Frederick	male	NaN	8	2	CA. 2343	69.55	NaN	S
324	325	0	3	Sage, Mr. George John Jr	male	NaN	8	2	CA. 2343	69.55	NaN	S
341	342	1	1	Fortune, Miss. Alice Elizabeth	female	24.0	3	2	19950	263.00	C23 C25 C27	S
792	793	0	3	Sage, Miss. Stella Anna	female	NaN	8	2	CA. 2343	69.55	NaN	S
846	847	0	3	Sage, Mr. Douglas Bullen	male	NaN	8	2	CA. 2343	69.55	NaN	S
863	864	0	3	Sage, Miss. Dorothy Edith "Dolly"	female	NaN	8	2	CA. 2343	69.55	NaN	S

• 10개의 이상치를 탐지

  • 28, 89, 342번 승객의 경우 매우 높은 Ticket,Fare를 가지고 있음

  • 나머지 7명의 경우 SibSp 값이 매우 높음

### 이상치 제거

train = train.drop(Outliers_to_drop, axis = 0).reset_index(drop = True) 
# 이상치가 있는 행을 날린 후 인덱스를 다시 부여

2-3. Train + Test set

### train, test set 결합
# 범주형 변수 변환 시 동일한 수의 feature를 얻기 위해서

train_len = len(train)
dataset =  pd.concat(objs = [train, test], axis = 0).reset_index(drop = True) # 행을 기준으로 결합

2-4. Null값, 결측치(Missing value) 확인

# 비어있거나 NaN인 값들을 NaN으로 채움
dataset = dataset.fillna(np.nan)

# 남은 null값 확인
dataset.isnull().sum()

PassengerId       0
Survived        418
Pclass            0
Name              0
Sex               0
Age             256
SibSp             0
Parch             0
Ticket            0
Fare              1
Cabin          1007
Embarked          2
dtype: int64

• Age와 Cabin에 매우 많은 결측치 존재

• 테스트 데이터 결합 시의 Survived의 결측치는 test set에 존재 x

  • concat 시 NaN 값을 대체해서

### 정보
train.info()
print()
train.isnull().sum()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 881 entries, 0 to 880
Data columns (total 12 columns):
 #   Column       Non-Null Count  Dtype  
---  ------       --------------  -----  
 0   PassengerId  881 non-null    int64  
 1   Survived     881 non-null    int64  
 2   Pclass       881 non-null    int64  
 3   Name         881 non-null    object 
 4   Sex          881 non-null    object 
 5   Age          711 non-null    float64
 6   SibSp        881 non-null    int64  
 7   Parch        881 non-null    int64  
 8   Ticket       881 non-null    object 
 9   Fare         881 non-null    float64
 10  Cabin        201 non-null    object 
 11  Embarked     879 non-null    object 
dtypes: float64(2), int64(5), object(5)
memory usage: 82.7+ KB

PassengerId      0
Survived         0
Pclass           0
Name             0
Sex              0
Age            170
SibSp            0
Parch            0
Ticket           0
Fare             0
Cabin          680
Embarked         2
dtype: int64

### 데이터 확인

train.head()

	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
3	4	1	1	Futrelle, Mrs. Jacques Heath (Lily May Peel)	female	35.0	1	0	113803	53.1000	C123	S
4	5	0	3	Allen, Mr. William Henry	male	35.0	0	0	373450	8.0500	NaN	S

### 데이터형 확인
train.dtypes

PassengerId      int64
Survived         int64
Pclass           int64
Name            object
Sex             object
Age            float64
SibSp            int64
Parch            int64
Ticket          object
Fare           float64
Cabin           object
Embarked        object
dtype: object

### 데이터 요약
# 통계량 제공

train.describe()

	PassengerId	Survived	Pclass	Age	SibSp	Parch	Fare
count	881.000000	881.000000	881.000000	711.000000	881.000000	881.000000	881.000000
mean	446.713961	0.385925	2.307605	29.731603	0.455165	0.363224	31.121566
std	256.617021	0.487090	0.835055	14.547835	0.871571	0.791839	47.996249
min	1.000000	0.000000	1.000000	0.420000	0.000000	0.000000	0.000000
25%	226.000000	0.000000	2.000000	20.250000	0.000000	0.000000	7.895800
50%	448.000000	0.000000	3.000000	28.000000	0.000000	0.000000	14.454200
75%	668.000000	1.000000	3.000000	38.000000	1.000000	0.000000	30.500000
max	891.000000	1.000000	3.000000	80.000000	5.000000	6.000000	512.329200

3. 변수(feature) 분석

3-1. 수치형(numerical) 변수

### 상관계수 행렬
# 수치형 변수들과 Survived 간의 상관계수

g = sns.heatmap(train[["Survived","SibSp","Parch",
                       "Age","Fare"]].corr(),annot = True, fmt = ".2f", cmap = "coolwarm")

• 오직 Fare 변수만이 Survived 변수와 유의한 상관관계를 보임

  • 다른 feature들이 중요하지 않다는 의미는 x

  • 해당 feature들의 파생 변수들이 Survived와 상관성을 가질 수 있음

• seaborn version issue로 인해 일부 함수 변경

(factorplot -> pointplot, catplot)

(distplot -> histplot)

∎ SibSp

g = sns.catplot(x = "SibSp",y = "Survived",data = train,
                   kind = "bar", palette = "muted")
g.despine(left = True)
g = g.set_ylabels("survival probability")

• 형제/배우자가 많을수록 생존률이 낮은 것으로 판단됨

  • 혼자인 승객(SibSp = 0)이나 한, 두명의 사람이 있는 경우(SibSp = 1 or 2)가 생존률이 더 높은 경향을 보임

∎ Parch

g = sns.catplot(x = "Parch",y = "Survived",data = train,
                   kind = "bar", palette = "muted")
g.despine(left = True)
g = g.set_ylabels("survival probability")

• 소가족이 독신 가족(Parch = 0)이나 중소 가족(Parch = 3,4), 대가족(Parch = 5,6)보다 생존률이 높음

• 부모/자녀가 3명인 승객의 생존률에 중요한 표준 편차가 있음

∎ Age

g = sns.FacetGrid(train, col = 'Survived')
g = g.map(sns.histplot, "Age", kde = True)

• 가우스 분포일 수도 있는 약간은 왜곡된(tailed) 분포를 보임

• 생존한 집단과 생존하지 못한 집단에서의 연령대 분포 양상이 다름

  • 생존한 집단 중 젊은 사람들의 비율이 높음

  • 60 ~ 80세 사이의 승객들의 생존률이 낮음

• Age와 Survived의 상관계수가 낮더라도, 생존 가능성이 높은 연령대가 존재함을 짐작할 수 있음

✔ 여담으로, 상관계수 행렬에서의 상관 계수(default = Pearson 상관계수)는 두 변수 간의 선형적 관계를 나타내는 측도이기에, 우리가 모르는 다른 관계가 존재항 수 있습니다..!

### 연령대 분포 시각화

g = sns.kdeplot(train["Age"][(train["Survived"] == 0) & (train["Age"].notnull())], 
                color = "Red", shade = True)
g = sns.kdeplot(train["Age"][(train["Survived"] == 1) & (train["Age"].notnull())], 
                ax = g, color = "Blue", shade = True)
g.set_xlabel("Age")
g.set_ylabel("Frequency")
g = g.legend(["Not Survived","Survived"])

• 두 밀도함수를 중첩하여 파악하면, 아기들과 매우 어린 아이들에 대응하는 peak를 볼 수 있음(Peak 0 ~ 5)

∎ Fare

### 결측치 확인

dataset["Fare"].isnull().sum()

1

### 결측치 -> 중간값
# 예측에 중요한 영향을 미치지 않을 것이라고 판단되는 중앙값 채택

dataset["Fare"] = dataset["Fare"].fillna(dataset["Fare"].median())

g = sns.histplot(dataset["Fare"], color="m", kde = True,
                 label = "Skewness : %.2f"%(dataset["Fare"].skew()))
g = g.legend(loc = "best")

• Fare 변수는 매우 왜곡된 분포를 띄고 있음

  • Scale이 조정된다 해도 모형의 가중치가 매우 높아지는 문제가 발생할 수 있음

  • 로그 변환(log transformation)을 통해 왜곡을 줄이는 것이 권장됨

### 로그 변환

dataset["Fare"] = dataset["Fare"].map(lambda i: np.log(i) if i > 0 else 0)

### 로그 변환 후 시각화

g = sns.histplot(dataset["Fare"], color="b", kde = True,
                 label="Skewness : %.2f"%(dataset["Fare"].skew()))
g = g.legend(loc="best")

• 로그 변환이 왜곡 정도를 굉장히 많이 감소시킴

3-2. 범주형(categorical) 변수

∎ Sex

g = sns.barplot(x = "Sex",y = "Survived",data = train)
g = g.set_ylabel("Survival Probability")

train[["Sex","Survived"]].groupby('Sex').mean()

	Survived
Sex
female	0.747573
male	0.190559

• 남성이 여성보다 생존률이 현저하게 낮음

  • Sex는 생존 여부를 예측하는 데 중요한 영향을 할 수 있음

∎ PClass

### 시각화

g = sns.catplot(x = "Pclass",y = "Survived",data = train, 
                kind = "bar", palette = "muted")
g.despine(left = True)
g = g.set_ylabels("survival probability")

g = sns.catplot(x = "Pclass", y = "Survived", hue = "Sex", 
                   data = train, kind = "bar", palette = "muted")
g.despine(left = True)
g = g.set_ylabels("survival probability")

• 3개의 클래스에 대해 각각의 클래스에서 생존률이 동일하지는 x

  • PClass = 1인 승객들은 PClass = 2, 3인 승객들에 비해 생존률이 높음

  • 남녀 상관 x

∎ Embarked

### 결측치 확인

dataset["Embarked"].isnull().sum()

2

### 결측치 처리
# 가장 많은 'S'로 대체

dataset["Embarked"] = dataset["Embarked"].fillna("S")

### 시각화

g = sns.catplot(x = "Embarked", y = "Survived", data = train,
                 kind = "bar", palette = "muted")
g.despine(left = True)
g = g.set_ylabels("survival probability")

• Cherbourg(C)에서 오는 승객들의 생존률이 더 높은 경향을 보임

  • 일등석 승객의 비율이 C에서 높을까?

### PClass vs Embarked

g = sns.catplot(x = "Pclass", col = "Embarked", data = train,
                kind = "count", palette = "muted")
g.despine(left = True)
g = g.set_ylabels("Count")

• 실제로 PClass = 3은 사우샘프턴(S)과 퀸스타운(Q)에서 오는 승객들에게 가장 빈번한 반면, 셰르부르(C)의 승객들은 대부분 생존율이 가장 높은 PClass = 1임

4. 결측치 처리

4-1. Age

• Age column에는 256개의 결측값이 포함되어 있음

• 생존 기회가 더 많은 하위 집단(ex> 어린이)이 있음

  • Age feature를 유지하고 누락된 값을 처리하는 것이 바람직

  • Age와 상관관계가 있는 변수들(Sex, Parch, Pclass, SibSP) 관찰

g = sns.catplot(y = "Age",x = "Sex",data = dataset, kind = "box")
g = sns.catplot(y = "Age", x = "Sex",hue="Pclass", data=dataset,kind="box")
g = sns.catplot(y="Age",x="Parch", data=dataset,kind="box")
g = sns.catplot(y="Age",x="SibSp", data=dataset,kind="box")

• 연령 분포는 남성과 여성 하위 모집단에서 동일한 것으로 보임

  • 성별은 연령을 예측하는 데 유용하지 x

• PClass = 1에 나이가 많은 승객들이 많음

  • 부모/자녀 수가 많을수록 나이가 많고, 형제/배우자가 많을수록 나이가 어려지는 경향이 있음

### Sex(범주형) -> 수치형

dataset["Sex"] = dataset["Sex"].map({"male": 0, "female":1})

### 상관계수 heatmap

g = sns.heatmap(dataset[["Age","Sex","SibSp","Parch","Pclass"]].corr(),
                cmap = "BrBG",annot = True)

• Parch를 제외한 feature들 간의 상관성을 시각적으로 제시

• 나이는 Sex와는 상관관계가 x

  • PClass, Parch, SibSp와는 음의 상관관계를 가짐

• Age - Parch 그래프에서 나이는 부모/자녀의 수에 따라 증가함

  • 하지만, 일반적인 상관관계는 음의 상관관계

• 나이 결측치 처리에 SibSp, Parch, PClass 활용

  • PClass, Parch 및 SibSp에 따라 유사한 행의 median 값으로 대체

### 결측치 처리

index_NaN_age = list(dataset["Age"][dataset["Age"].isnull()].index) # 결측치 데이터의 index

for i in index_NaN_age:
    age_med = dataset["Age"].median()
    age_pred = dataset["Age"][((dataset['SibSp'] == dataset.iloc[i]["SibSp"]) & (dataset['Parch'] == dataset.iloc[i]["Parch"]) & (dataset['Pclass'] == dataset.iloc[i]["Pclass"]))].median()
    
    if not np.isnan(age_pred):
        dataset['Age'].iloc[i] = age_pred
    else:
        dataset['Age'].iloc[i] = age_med

g = sns.catplot(x = "Survived", y = "Age",data = train, kind = "box")
g = sns.catplot(x = "Survived", y = "Age",data = train, kind = "violin")

• 생존한 그룹의 연령의 중간값과 생존하지 못한 그룹의 연령의 중간값 사이에는 상당한 차이가 존재

• violin plot을 통해 여전히 매우 어린 승객들의 생존률이 더 높음을 확인할 수 있음

5. 특성 공학(Feature Engineering)

5-1. Name/ Title

dataset["Name"].head()

0                              Braund, Mr. Owen Harris
1    Cumings, Mrs. John Bradley (Florence Briggs Th...
2                               Heikkinen, Miss. Laina
3         Futrelle, Mrs. Jacques Heath (Lily May Peel)
4                             Allen, Mr. William Henry
Name: Name, dtype: object

• Name feature에는 승객의 제목에 대한 정보가 포함되어 있음

• 대피하는 동안 구별되는 호칭을 가진 일부 승객이 선호될 수 있기 때문에, 이들을 새로운 변수로 활용

dataset_title = [i.split(",")[1].split(".")[0].strip() for i in dataset["Name"]]
dataset["Title"] = pd.Series(dataset_title)
dataset["Title"].head()

0      Mr
1     Mrs
2    Miss
3     Mrs
4      Mr
Name: Title, dtype: object

### 시각화

g = sns.countplot(x="Title",data=dataset)
g = plt.setp(g.get_xticklabels(), rotation = 45)

• 17개의 title이 존재

  • 대부분 거의 없고 약 4개로 거의 다 구분 가능

### Title(범주형 변수) -> 수치형 변수

# 4개의 범주로 재분류
dataset["Title"] = dataset["Title"].replace(['Lady', 'the Countess','Countess','Capt', 'Col','Don', 'Dr', 'Major', 'Rev', 'Sir', 'Jonkheer', 'Dona'], 'Rare')
dataset["Title"] = dataset["Title"].map({"Master":0, "Miss":1, "Ms" : 1 , "Mme":1, "Mlle":1, "Mrs":1, "Mr":2, "Rare":3})
dataset["Title"] = dataset["Title"].astype(int)

### 시각화

g = sns.countplot(dataset["Title"])
g = g.set_xticklabels(["Master","Miss/Ms/Mme/Mlle/Mrs","Mr","Rare"])

• 에러 발생

g = sns.catplot(x="Title",y="Survived",data=dataset,kind="bar")
g = g.set_xticklabels(["Master","Miss-Mrs","Mr","Rare"])
g = g.set_ylabels("survival probability")

• 여자와 아이들의 생존률이 더 높음을 확인할 수 있다.

• 특이한 title을 가진 승객들의 생존률이 더 높다.

### 기존의 이름 변수를 drop

dataset.drop(labels = ["Name"], axis = 1, inplace = True)

5-2. Family Size

• SibSp, Parch와 여기에 1(자기 자신)을 더해 FSize라는 변수 생성

dataset["Fsize"] = dataset["SibSp"] + dataset["Parch"] + 1

### 시각화

g = sns.pointplot(x = "Fsize",y = "Survived",data = dataset, )
g = g.set_ylabel("Survival Probability")

• 가족 규모가 중요한 역할을 하는 것처럼 보임

  • 대가족의 생존 확률은 최악임

• 추가적으로 4개의 가족 크기 category를 생성하자

### 새로운 카테고리 생성
dataset['Single'] = dataset['Fsize'].map(lambda s: 1 if s == 1 else 0)
dataset['SmallF'] = dataset['Fsize'].map(lambda s: 1 if  s == 2  else 0)
dataset['MedF'] = dataset['Fsize'].map(lambda s: 1 if 3 <= s <= 4 else 0)
dataset['LargeF'] = dataset['Fsize'].map(lambda s: 1 if s >= 5 else 0)

### 시각화

g = sns.catplot(x="Single",y="Survived",data=dataset,kind="bar")
g = g.set_ylabels("Survival Probability")

g = sns.catplot(x="SmallF",y="Survived",data=dataset,kind="bar")
g = g.set_ylabels("Survival Probability")

g = sns.catplot(x="MedF",y="Survived",data=dataset,kind="bar")
g = g.set_ylabels("Survival Probability")

g = sns.catplot(x="LargeF",y="Survived",data=dataset,kind="bar")
g = g.set_ylabels("Survival Probability")

• 소가족이나 중간 정도 크기의 가족들이 혼자 탑승한 승객이나 대가족들보다 생존률이 높음

### 수치형 변수로 변환
# One-hot Encoding 진행

dataset = pd.get_dummies(dataset, columns = ["Title"])
dataset = pd.get_dummies(dataset, columns = ["Embarked"], prefix="Em")

dataset.head()

	PassengerId	Survived	Pclass	Sex	Age	SibSp	Parch	Ticket	Fare	Cabin	...	SmallF	MedF	LargeF	Title_0	Title_1	Title_2	Title_3	Em_C	Em_Q	Em_S
0	1	0.0	3	0	22.0	1	0	A/5 21171	1.981001	NaN	...	1	0	0	0	0	1	0	0	0	1
1	2	1.0	1	1	38.0	1	0	PC 17599	4.266662	C85	...	1	0	0	0	1	0	0	1	0	0
2	3	1.0	3	1	26.0	0	0	STON/O2. 3101282	2.070022	NaN	...	0	0	0	0	1	0	0	0	0	1
3	4	1.0	1	1	35.0	1	0	113803	3.972177	C123	...	1	0	0	0	1	0	0	0	0	1
4	5	0.0	3	0	35.0	0	0	373450	2.085672	NaN	...	0	0	0	0	0	1	0	0	0	1

5 rows × 22 columns

• 현 시점에서 22개의 feature를 가짐

5-3. Cabin

dataset["Cabin"].head()

0     NaN
1     C85
2     NaN
3    C123
4     NaN
Name: Cabin, dtype: object

dataset["Cabin"].describe()

count     292
unique    186
top        G6
freq        5
Name: Cabin, dtype: object

dataset["Cabin"].isnull().sum()

1007

• 292개의 값과 1007개의 결측치가 존재

  • 객실이 없는 승객은 객실 번호 대신 누락된 값이 표시되는 것으로 생각

dataset["Cabin"][dataset["Cabin"].notnull()].head()

1      C85
3     C123
6      E46
10      G6
11    C103
Name: Cabin, dtype: object

### 결측치의 경우 'X'로 표기

dataset["Cabin"] = pd.Series([i[0] if not pd.isnull(i) else 'X' for i in dataset['Cabin'] ])

• Cabin의 첫 글자는 Desk를 포함

  • Titanic호에서 승객이 있을 만한 위치를 포함

g = sns.countplot(dataset["Cabin"],
                  order=['A','B','C','D','E','F','G','T','X'])

g = sns.catplot(y="Survived",x="Cabin",data=dataset,kind="bar",
                order=['A','B','C','D','E','F','G','T','X'])
g = g.set_ylabels("Survival Probability")

• 객실이 있는 승객의 수가 적음

  • 생존 확률은 중요한 표준 편차를 가지며 다른 desk에 있는 승객의 생존 확률을 구별할 수 없음

• 하지만 일반적으로 객실을 가진 승객이 객실이 없는 승객보다 생존할 수 있는 기회가 더 많다는 것을 알 수 있음

  • 특히 객실 B, C, D, E, F에 해당

### 범주형 변수 -> 수치형 변수

dataset = pd.get_dummies(dataset, columns = ["Cabin"],prefix="Cabin")

5-4. Ticket

dataset["Ticket"].head()

0           A/5 21171
1            PC 17599
2    STON/O2. 3101282
3              113803
4              373450
Name: Ticket, dtype: object

• 같은 접두사를 공유하는 티켓이 함께 배치된 객실에 예약될 수 있다는 것을 의미하는 것일 수 있음 -> 실제 선실 배치와 연결될 수 있음

• 동일한 접두사를 가진 티켓은 PClass와 Survived가 유사할 수 있음

  • 접두어만을 추출

### 접두어만을 추출
# 만약 없다면 'X'로 표기

Ticket = []
for i in list(dataset.Ticket):
    # 접두어가 있는 경우
    if not i.isdigit():
        Ticket.append(i.replace(".","").replace("/","").strip().split(' ')[0]) 
    else:
        Ticket.append("X")
        
dataset["Ticket"] = Ticket
dataset["Ticket"].head()

0        A5
1        PC
2    STONO2
3         X
4         X
Name: Ticket, dtype: object

### One-hot Encoding

dataset = pd.get_dummies(dataset, columns = ["Ticket"], prefix = "T")

### PClass에 대한 범주형 변수 생성

dataset["Pclass"] = dataset["Pclass"].astype("category")
dataset = pd.get_dummies(dataset, columns = ["Pclass"],prefix = "Pc")

### 불필요한 변수 날리기
dataset.drop(labels = ["PassengerId"], axis = 1, inplace = True)

dataset.head()

	Survived	Sex	Age	SibSp	Parch	Fare	Fsize	Single	SmallF	MedF	...	T_STONO	T_STONO2	T_STONOQ	T_SWPP	T_WC	T_WEP	T_X	Pc_1	Pc_2	Pc_3
0	0.0	0	22.0	1	0	1.981001	2	0	1	0	...	0	0	0	0	0	0	0	0	0	1
1	1.0	1	38.0	1	0	4.266662	2	0	1	0	...	0	0	0	0	0	0	0	1	0	0
2	1.0	1	26.0	0	0	2.070022	1	1	0	0	...	0	1	0	0	0	0	0	0	0	1
3	1.0	1	35.0	1	0	3.972177	2	0	1	0	...	0	0	0	0	0	0	1	1	0	0
4	0.0	0	35.0	0	0	2.085672	1	1	0	0	...	0	0	0	0	0	0	1	0	0	1

5 rows × 67 columns

6. 모델링(Modeling)

### Train, Test를 다시 나누기

train = dataset[:train_len]
test = dataset[train_len:]
test.drop(labels=["Survived"],axis = 1,inplace=True)

### feature(X) vs label(y)

train["Survived"] = train["Survived"].astype(int)

Y_train = train["Survived"]
X_train = train.drop(labels = ["Survived"],axis = 1)

6-1. 단순한 모델링

a. 교차 검증(Cross Validate) 모델

• 10개의 인기 있는 분류기를 비교

• stratified k-fold 교차 검증 방식 -> 각 분류기의 평균 정확도를 평가

• 활용 모델

  • SVC

  • Decision Tree

  • AdaBoost

  • Random Forest

  • Extra Trees

  • Gradient Boosting

  • Multiple layer perceprton (neural network)

  • KNN

  • Logistic regression

  • Linear Discriminant Analysis

kfold = StratifiedKFold(n_splits = 10)

### modeling

random_state = 2

# 모델 객체 생성
classifiers = []
classifiers.append(SVC(random_state=random_state))
classifiers.append(DecisionTreeClassifier(random_state=random_state))
classifiers.append(AdaBoostClassifier(DecisionTreeClassifier(random_state=random_state),
                                      random_state=random_state,learning_rate=0.1))
classifiers.append(RandomForestClassifier(random_state=random_state))
classifiers.append(ExtraTreesClassifier(random_state=random_state))
classifiers.append(GradientBoostingClassifier(random_state=random_state))
classifiers.append(MLPClassifier(random_state=random_state))
classifiers.append(KNeighborsClassifier())
classifiers.append(LogisticRegression(random_state = random_state))
classifiers.append(LinearDiscriminantAnalysis())

# 교차 검증
cv_results = []
for classifier in classifiers:
    cv_results.append(cross_val_score(classifier, X_train, y = Y_train, 
                                      scoring = "accuracy", cv = kfold, n_jobs=4))
# 평가
cv_means = []
cv_std = []
for cv_result in cv_results:
    cv_means.append(cv_result.mean())
    cv_std.append(cv_result.std())

cv_res = pd.DataFrame({"CrossValMeans":cv_means,"CrossValerrors": cv_std,
                       "Algorithm":["SVC","DecisionTree","AdaBoost","RandomForest",
                                    "ExtraTrees","GradientBoosting",
                                    "MultipleLayerPerceptron","KNeighboors",
                                    "LogisticRegression","LinearDiscriminantAnalysis"]})

### 시각화

g = sns.barplot(x = "CrossValMeans",y = "Algorithm",data = cv_res, 
                palette = "Set3",orient = "h",**{'xerr':cv_std})
g.set_xlabel("Mean Accuracy")
g = g.set_title("Cross validation scores")

• 앙상블 모델링을 위해 SVC, AdaBoost, RandomForest , ExtraTrees, GradientBoosting 모델 선택

b. 최적 모델을 위한 하이퍼 파라미터 튜닝(hyper parameter tuning)

• Grid Search 최적화를 수행

### 메타 모델링(Meta Modeling)

# Adaboost
DTC = DecisionTreeClassifier()
adaDTC = AdaBoostClassifier(DTC, random_state=7)
ada_param_grid = {"base_estimator__criterion" : ["gini", "entropy"],
              "base_estimator__splitter" :   ["best", "random"],
              "algorithm" : ["SAMME","SAMME.R"],
              "n_estimators" :[1,2],
              "learning_rate":  [0.0001, 0.001, 0.01, 0.1, 0.2, 0.3,1.5]}

gsadaDTC = GridSearchCV(adaDTC,param_grid = ada_param_grid, cv=kfold, 
                        scoring="accuracy", n_jobs= 4, verbose = 1)
gsadaDTC.fit(X_train,Y_train)
ada_best = gsadaDTC.best_estimator_

gsadaDTC.best_score_

0.8275536261491316

# ExtraTrees 
ExtC = ExtraTreesClassifier()

ex_param_grid = {"max_depth": [None],
              "max_features": [1, 3, 10],
              "min_samples_split": [2, 3, 10],
              "min_samples_leaf": [1, 3, 10],
              "bootstrap": [False],
              "n_estimators" :[100,300],
              "criterion": ["gini"]}

gsExtC = GridSearchCV(ExtC,param_grid = ex_param_grid, cv=kfold, 
                      scoring="accuracy", n_jobs= 4, verbose = 1)

gsExtC.fit(X_train,Y_train)
ExtC_best = gsExtC.best_estimator_

# Best score
gsExtC.best_score_

Fitting 10 folds for each of 54 candidates, totalling 540 fits

0.8286133810010214

# RFC Parameters tunning 
RFC = RandomForestClassifier()

rf_param_grid = {"max_depth": [None],
              "max_features": [1, 3, 10],
              "min_samples_split": [2, 3, 10],
              "min_samples_leaf": [1, 3, 10],
              "bootstrap": [False],
              "n_estimators" :[100,300],
              "criterion": ["gini"]}

gsRFC = GridSearchCV(RFC,param_grid = rf_param_grid, cv=kfold, 
                     scoring="accuracy", n_jobs= 4, verbose = 1)
gsRFC.fit(X_train,Y_train)
RFC_best = gsRFC.best_estimator_

# Best score
gsRFC.best_score_

Fitting 10 folds for each of 54 candidates, totalling 540 fits

0.8320224719101124

# Gradient boosting tunning

GBC = GradientBoostingClassifier()
gb_param_grid = {'loss' : ["deviance"],
              'n_estimators' : [100,200,300],
              'learning_rate': [0.1, 0.05, 0.01],
              'max_depth': [4, 8],
              'min_samples_leaf': [100,150],
              'max_features': [0.3, 0.1] 
              }

gsGBC = GridSearchCV(GBC,param_grid = gb_param_grid, cv=kfold, 
                     scoring="accuracy", n_jobs= 4, verbose = 1)
gsGBC.fit(X_train,Y_train)
GBC_best = gsGBC.best_estimator_

# Best score
gsGBC.best_score_

Fitting 10 folds for each of 72 candidates, totalling 720 fits

/usr/local/lib/python3.9/dist-packages/sklearn/ensemble/_gb.py:280: FutureWarning: The loss parameter name 'deviance' was deprecated in v1.1 and will be removed in version 1.3. Use the new parameter name 'log_loss' which is equivalent.
  warnings.warn(

0.8376915219611849

# SVC classifier
SVMC = SVC(probability=True)
svc_param_grid = {'kernel': ['rbf'], 
                  'gamma': [ 0.001, 0.01, 0.1, 1],
                  'C': [1, 10, 50, 100,200,300, 1000]}

gsSVMC = GridSearchCV(SVMC,param_grid = svc_param_grid, cv=kfold, 
                      scoring="accuracy", n_jobs= 4, verbose = 1)

gsSVMC.fit(X_train,Y_train)
SVMC_best = gsSVMC.best_estimator_

# Best score
gsSVMC.best_score_

Fitting 10 folds for each of 28 candidates, totalling 280 fits

0.8331332992849847

c. 학습 곡선(learning curve) 시각화

• training set에서의 overfitting

• 정확도에 training size가 미치는 영향 파악

### 시각화를 위한 함수 정의

def plot_learning_curve(estimator, title, X, y, ylim=None, cv=None,
                        n_jobs=-1, train_sizes=np.linspace(.1, 1.0, 5)):
  
    """Generate a simple plot of the test and training learning curve"""
    plt.figure()
    plt.title(title)
    if ylim is not None:
        plt.ylim(*ylim)
    plt.xlabel("Training examples")
    plt.ylabel("Score")

    train_sizes, train_scores, test_scores = learning_curve(
        estimator, X, y, cv=cv, n_jobs=n_jobs, train_sizes=train_sizes)
    train_scores_mean = np.mean(train_scores, axis=1)
    train_scores_std = np.std(train_scores, axis=1)
    test_scores_mean = np.mean(test_scores, axis=1)
    test_scores_std = np.std(test_scores, axis=1)
    plt.grid()

    plt.fill_between(train_sizes, train_scores_mean - train_scores_std,
                     train_scores_mean + train_scores_std, alpha=0.1,
                     color="r")
    plt.fill_between(train_sizes, test_scores_mean - test_scores_std,
                     test_scores_mean + test_scores_std, alpha=0.1, color="g")
    plt.plot(train_sizes, train_scores_mean, 'o-', color="r",
             label="Training score")
    plt.plot(train_sizes, test_scores_mean, 'o-', color="g",
             label="Cross-validation score")

    plt.legend(loc="best")
    
    return plt

### 시각화

g = plot_learning_curve(gsRFC.best_estimator_,"RF mearning curves",
                        X_train,Y_train,cv=kfold)
g = plot_learning_curve(gsExtC.best_estimator_,"ExtraTrees learning curves",
                        X_train,Y_train,cv=kfold)
g = plot_learning_curve(gsSVMC.best_estimator_,"SVC learning curves",
                        X_train,Y_train,cv=kfold)
g = plot_learning_curve(gsadaDTC.best_estimator_,"AdaBoost learning curves",
                        X_train,Y_train,cv=kfold)
g = plot_learning_curve(gsGBC.best_estimator_,"GradientBoosting learning curves",
                        X_train,Y_train,cv=kfold)

• GradientBoosting 및 Adaboost 분류기는 훈련 세트에 overfitting된 경향이 있음

  • 증가하는 교차 검증 곡선에 따라 GradientBoost와 Adboost는 더 많은 훈련 예제를 통해 더 나은 성능을 발휘할 수 있음

• SVC와 ExtraTree 분류기는 훈련과 교차 검증 곡선이 서로 비슷함

  • 예측을 더 잘 일반화하는 것으로 보임

d. 피쳐 중요도 & 트리 기반 분류

• 승객 생존 예측을 위한 가장 유용한 특징 파악

nrows = ncols = 2
fig, axes = plt.subplots(nrows = nrows, ncols = ncols, sharex="all", figsize=(15,15))

names_classifiers = [("AdaBoosting", ada_best),("ExtraTrees",ExtC_best),
                     ("RandomForest",RFC_best),("GradientBoosting",GBC_best)]

nclassifier = 0
for row in range(nrows):
    for col in range(ncols):
        name = names_classifiers[nclassifier][0]
        classifier = names_classifiers[nclassifier][1]
        indices = np.argsort(classifier.feature_importances_)[::-1][:40]
        
        g = sns.barplot(y = X_train.columns[indices][:40],
                        x = classifier.feature_importances_[indices][:40] , 
                        orient='h',ax=axes[row][col])
        g.set_xlabel("Relative importance",fontsize=12)
        g.set_ylabel("Features",fontsize=12)
        g.tick_params(labelsize=9)
        g.set_title(name + " feature importance")
        
        nclassifier += 1

• 4개의 트리 기반 분류기(Adaboost, ExtraTree, RandomForest 및 GradientBoost)에 대한 feature 중요도를 표시

• 네 개의 분류기가 상대적 중요성에 따라 다른 최상위 feature 가지고 있음

  • 예측이 같은 feature에 근거하지 않는다는 것을 의미

• Title_2는 Mrs/Mlle/Mme/Miss/Ms 범주가 Sex와 높은 상관관계가 있음

  • Discussion:

    • Pc_1, Pc_2, Pc_3 및 요금은 승객의 일반적인 사회적 지위를 나타냄

    • Sex와 Title_2(Mrs/Mlle/Mme/Miss/Ms) 및 Title_3(Mr)은 성별을 의미

    • 연령과 Title_1(Master)는 승객의 연령

    • Fsize, LargeF, MedF, Single은 승객의 가족 수 크기를 의미

생존 예측은 보트 안의 위치보다는 승객의 나이, 성별, 가족 규모, 사회적 지위와 더 관련이 있음

### 각각의 모델에 대해 예측값 도출
test_Survived_RFC = pd.Series(RFC_best.predict(test), name="RFC")
test_Survived_ExtC = pd.Series(ExtC_best.predict(test), name="ExtC")
test_Survived_SVMC = pd.Series(SVMC_best.predict(test), name="SVC")
test_Survived_AdaC = pd.Series(ada_best.predict(test), name="Ada")
test_Survived_GBC = pd.Series(GBC_best.predict(test), name="GBC")


# 모든 결과 통합
ensemble_results = pd.concat([test_Survived_RFC,test_Survived_ExtC,test_Survived_AdaC,
                              test_Survived_GBC, test_Survived_SVMC], axis = 1)

# 시각화
g = sns.heatmap(ensemble_results.corr(),annot=True)

• Adboost가 다른 분류기와 비교되는 경우를 제외하고는 5개 분류기에 대해 상당히 유사한 것으로 보임

• 5개의 분류기는 거의 동일한 예측을 제공하지만 약간의 차이가 있음

  • ensembling voting 활용하기에 충분

6-2. 모델 앙상블(Ensemble)

###a. 모델 결합하기

• VotingClassifier를 선택

• soft 지정: 각 vote에서의 확률 고려

votingC = VotingClassifier(estimators=[('rfc', RFC_best), ('extc', ExtC_best),
                                       ('svc', SVMC_best), ('adac',ada_best),
                                       ('gbc',GBC_best)], voting='soft', n_jobs=4)
votingC = votingC.fit(X_train, Y_train)

6-3. 예측(Prediction)

a. 예측 & 결과 도출

test_Survived = pd.Series(votingC.predict(test), name="Survived")
results = pd.concat([IDtest,test_Survived],axis=1)
results.to_csv("ensemble_python_voting.csv",index=False)