파이썬 머신러닝 완벽 가이드 - 2.6 - 사이킷런으로 수행하는 타이타닉 생존자 예측

# 사용할 라이브러리 가져오기

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

titanic_df = pd.read_csv('./train.csv')
titanic_df.head(3)

[그림1] 타이타닉 데이터 3개 확인

 

# 데이터 칼럼 타입 확인

print('\n ### 학습 데이터 정보 ### \n')
print(titanic_df.info())

[그림2] 칼럼 타입 확인

 

• 891개의 로우
• 칼럼 12개

 

Null 값 변경

# Null 값 변경
# age - 평균 나이
# 나머지 칼럼은 'N'값으로 변경

titanic_df['Age'].fillna(titanic_df['Age'].mean(), inplace=True)
titanic_df['Cabin'].fillna('N', inplace=True)
titanic_df['Embarked'].fillna('N',inplace=True)
print('데이터 세트 Null 값 개수 ', titanic_df.isnull().sum().sum())

[그림3] Null 값 변경

피처들의 값 분류 확인

print('Sex 값 분포 :\n', titanic_df['Sex'].value_counts())
print('\n Cabin 값 분포 : \n', titanic_df['Cabin'].value_counts())
print('\n Embarked 값 분포 : \n', titanic_df['Embarked'].value_counts())

[그림4] 피처들의 값 분류 확인

titanic_df['Cabin'] = titanic_df['Cabin'].str[:1]
print(titanic_df['Cabin'].head(3))

[그림5] Cabin 첫 글자 알파벳만 

 

생존확률을 확인하기 위해 성별에 따른 생존자 수 확인

titanic_df.groupby(['Sex', 'Survived'])['Survived'].count()

[그림6] 성별에 따른 생존자 수 확인

막대 차트로 확인

sns.barplot(x='Sex', y = 'Survived', data=titanic_df)

[그림7] 막대 차트로 성별에 따른 생존자 비교

 

부자와 가난한 사람 비교 - 객실의 등급을 비교해 확인

sns.barplot(x='Pclass', y = 'Survived', hue='Sex', data=titanic_df)

[그림8] 부자와 가난한 사람의 생존자 수 비교

• 삼등실의 경우 생존 확률이 상대적으로 떨어진다.

 

나이에 따른 생존 확률 알아보기

# 입력 age에 따라 구분 값을 반환하는 함수 설정 

def get_category(age):
    cat = ''
    if age <= -1 : cat = 'Unknown'
    elif age <=5 : cat = 'Baby'
    elif age <= 12 : cat = 'Child'
    elif age <= 18 : cat = 'Teenager'
    elif age <= 25 : cat ='Student'
    elif age <= 35 : cat = 'Young Adult'
    elif age <= 60 : cat = 'Adult'
    else : cat = 'Elderly'
        # 나이에 따라 구분
    return cat

# 막대그래프의 크기 figure를 더 크게 설정
plt.figure(figsize = (10,6))

# x축의 값을 순차적으로 표시하기 위한 설정
group_names = ['Unkown','Baby','Child','Teenager','Student','Young Adult','Adult',
              'Elderly']

titanic_df['Age_cat'] = titanic_df['Age'].apply(lambda x:get_category(x))
sns.barplot(x='Age_cat', y='Survived', hue = 'Sex', data=titanic_df, order=group_names)
titanic_df.drop('Age_cat', axis = 1, inplace=True)

[그림9] 나이에 따른 생존자

• 어릴수록 남자와 여자 구분이 없지만 나이가 많아질수록 여자의 생존확률이 높아진다.

# encode_features() 함수 새로 생성해 한 번에 변환하도록

from sklearn import preprocessing

def encode_features(dataDF):
    features = ['Cabin', 'Sex', 'Embarked']
    for feature in features:
        le = preprocessing.LabelEncoder()
        le = le.fit(dataDF[feature])
        dataDF[feature] = le.transform(dataDF[feature])
        
    return dataDF

titanic_df = encode_features(titanic_df)
titanic_df.head()

[그림10] Sex, Cabin, Embarked 숫자형으로 바뀜

 

데이터 전처리 함수로 만들기

# Null 처리 함수
def fillna(df):
    df['Age'].fillna(df['Age'].mean(), inplace=(True))
    df['Cabin'].fillna('N', inplace=True)
    df['Embarked'].fillna('N', inplace=True)
    df['Fare'].fillna(0, inplace=True)
    
    return fillna()

# 머신러닝 알고리즘에 불필요한 요소 제거

def drop_features(df):
    df.drop(['PassengerId','Name','Ticket'],axis = 1, inplace=True)
    return df

# 레이블 인코딩 수행
def format_features(df):
    features = ['Cabin', 'Sex', 'Embarked']
    for feature in features:
        le = preprocessing.LabelEncoder()
        le = le.fit(dataDF[feature])
        dataDF[feature] = le.transform(dataDF[feature])
        
    return dataDF

# 앞에서 설정한 데이터 전처리 함수 호출
def transform_features(df):
    df = fillna(df)
    df = drop_features(df)
    df = format_features(df)
    return df

 

데이터 가공

# 원본 데이터 재로딩, 피처 데이터 세트와 레이블 데이터 세트 추출

titanic_df = pd.read_csv('./train.csv')
y_titanic_df = titanic_df['Survived']
x_titanic_df = titanic_df.drop('Survived', axis=1)

x_titanic_df = transform_features(x_titanic_df)

# 데이터 세트 나누기

from sklearn.model_selection import train_test_split

x_train, x_test, y_train, y_test = train_test_split(x_titanic_df, y_titanic_df,
                                                   test_size = 0.2, random_state=11)

 

결정트리, 랜덤 포레스트, 로지스틱 회귀로 모델 학습, 예측, 평가

from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score

# 결정 트리, Random Forest, 로지스틱 회귀를 위한 사이킷런 Classifier 클래스 생성

dt_clf = DecisionTreeClassifier(random_state=11)
rf_clf = RandomForestClassifier(random_state=11)
lr_clf = LogisticRegression()

# DecisionTreeClassifier 학습/예측/평가
dt_clf.fit(x_train, y_train)
dt_pred = dt_clf.predict(x_test)
print('DecisionTreeClassifier 정확도 : {0:.4f}'.format(accuracy_score(y_test, dt_pred)))

# RandomForestClassifier 학습/예측/평가
rf_clf.fit(x_train, y_train)
rf_pred = rf_clf.predict(x_test)
print('RandomForestClassifier 정확도 : {0:.4f}'.format(accuracy_score(y_test, rf_pred)))


# LogisticRegression
lr_clf.fit(x_train, y_train)
lr_pred = lr_clf.predict(x_test)
print('LogisticRegrssion 정확도 : {0:.4f}'.format(accuracy_score(y_test, lr_pred)))

 

교차 검증

# 교차 검증

from sklearn.model_selection import KFold

def exec_kfold(clf, folds=5):
    # 폴드 세트 5개인 KFold 생성, 
    kfold = KFold(n_splits=folds)
    scores = []
    
    # KFold 교차 검증 수행
    for iter_count, (train_index, test_index) in enumerate(kfold.split(x_titanic_df)):
        # x_titanic_df 데이터에서 교차 검증별로 학습과 검증 데이터를 가리키는 index 생성
        x_train, x_test = x_titanic_df.values[train_index], x_titanic_df.values[test_index]
        y_train, y_test = y_titanic_df.values[train_index], y_titanic_df.values[test_index]
        # Classifier 학습, 예측, 정확도 계산
        clf.fit(x_train, y_train)
        predictions = clf.predict(x_test)
        accuracy = accuracy_score(y_test, predictions)
        scores.append(accuracy)
        print("교차 검증 {0} 정확도 : {1:.4f}".format(iter_count, accuracy))
        
    # 5개의 fold 에서 평균 정확도 계산
    mean_score = np.mean(scores)
    print("평균 정확도 : {0:.4f}".format(mean_score))
exec_kfold(dt_clf, folds=5)

[그림11] 교차 검증 정확도