사이킷런으로 수행하는 타이타닉 생존자 예측

DACON - 주차 수요 예측  AI 경진대회

 

-----------------------------------------------------
> [예제] 사이킷런으로 수행하는 타이타닉 생존자 예측 <
-----------------------------------------------------

# Data Loading
# - 변수 설명 : https://computer-science-student.tistory.com/113
#
# Data Preprocessing
# - Null 처리
# - 불필요한 속성 제거
# - 인코딩 수행
#
# Model 학습 -> 예측 -> 평가 -> 최적화
# - Model 학습, 예측, 정확도 평가 : DecisionTreeClassifier, RandomForestClassifier, LogisticRegression
# - 교차검증으로 평가 : KFold Cross Validation
# - 교차검증으로 평가 : cross_val_score()
# - 하이퍼 파라미터 최적화 : GridSearchCV()

 

 

Titanic 생존자 예측

타이타닉 호 침몰 사건 당시의 사망자와 생존자를 구분하는 요인 분석을 통해, 승객들의 생존 여부를 예측

 

필요한 라이브러리 설치

In [1]:

# 데이터 불러오기 import pandas as pd import numpy as np import random as rnd

In [2]:

# 시각화 import seaborn as sns import matplotlib.pyplot as plt %matplotlib inline

In [3]:

# 머신러닝

from sklearn.linear_model import LogisticRegression

from sklearn.svm import SVC, LinearSVC

from sklearn.ensemble import RandomForestClassifier

from sklearn.neighbors import KNeighborsClassifier

from sklearn.naive_bayes import GaussianNB

from sklearn.linear_model import Perceptron

from sklearn.linear_model import SGDClassifier

from sklearn.tree import DecisionTreeClassifier

 

import warnings warnings.filterwarnings(action='ignore')

 

데이터 셋 불러오기

- train.csv : 모델 학습에 사용되는 데이터- test.csv : 모델 적용 대상이 되는 데이터

In [5]:

train_df=pd.read_csv("titanic/train.csv") test_df=pd.read_csv("titanic/test.csv") # 모델 적용의 일관성을 위해, # train과 test를 합한 combine 데이터 셋도 지정 combine=[train_df,test_df]

 

데이터 변수(Feature) 확인

In [6]:

# 변수 보기 print(train_df.columns.values)

 

['PassengerId' 'Survived' 'Pclass' 'Name' 'Sex' 'Age' 'SibSp' 'Parch' 'Ticket' 'Fare' 'Cabin' 'Embarked']

 

변수설명

PassengerId : 각 승객의 고유 번호

Survived : 생존 여부(종속 변수)

• 0 = 사망
• 1 = 생존

Pclass : 객실 등급 - 승객의 사회적, 경제적 지위

• 1st = Upper
• 2nd = Middle
• 3rd = Lower

Name : 이름

Sex : 성별

Age : 나이

SibSp : 동반한 Sibling(형제자매)와 Spouse(배우자)의 수

Parch : 동반한 Parent(부모) Child(자식)의 수

Ticket : 티켓의 고유넘버

Fare : 티켓의 요금

Cabin : 객실 번호

Embarked : 승선한 항

• C = Cherbourg
• Q = Queenstown
• S = Southampton

 

---

 

 

# Data Loading
# - 변수 설명 : https://computer-science-student.tistory.com/113
#
# Data Preprocessing
# - Null 처리
# - 불필요한 속성 제거
# - 인코딩 수행
#
# Model 학습 -> 예측 -> 평가 -> 최적화
# - Model 학습, 예측, 정확도 평가 : DecisionTreeClassifier, RandomForestClassifier, LogisticRegression
# - 교차검증으로 평가 : KFold Cross Validation
# - 교차검증으로 평가 : cross_val_score()
# - 하이퍼 파라미터 최적화 : GridSearchCV()


### 모듈, 함수, 클래스 임포트

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

from sklearn import preprocessing
from sklearn.preprocessing import LabelEncoder

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

from sklearn.metrics import accuracy_score

from sklearn.model_selection import train_test_split
from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import GridSearchCV


### 데이터 로딩한 뒤 Null 값 처리

# 데이터 로딩
titanic_df = pd.read_csv("D://pythonclass//train.csv")

# 로딩된 데이터 확인
titanic_df.head(3)

# train 데이터셋 정보 확인
titanic_df.info()

# Age, Cabin, Embarked 컬럼의 Null 값 처리
titanic_df['Age'].fillna(titanic_df['Age'].mean(), inplace=True) # 비어있는 age에 평균을 넣음
titanic_df['Cabin'].fillna('N', inplace=True) # null에 N 넣음
titanic_df['Embarked'].fillna('N', inplace=True) # null에 N 넣음

# 데이터셋 전체 Null 값 갯수 확인
titanic_df.isnull()
titanic_df.isnull().sum()
titanic_df.isnull().sum().sum() # 전체의 null값 확인


### 탐색적 데이터 분석

titanic_df['Sex'].value_counts()  # 성별 카운트
titanic_df['Cabin'].value_counts()  # 선실 번호별 카운트
titanic_df['Embarked'].value_counts()  # 중간 정착 항구별 카운트

# 선실 등급을 나타내는 첫번째 알파벳 자르기
titanic_df['Cabin'] = titanic_df['Cabin'].str[:1] # 등급의 첫글자만 추출
titanic_df['Cabin'].head(3)

# 성별 생존자별 카운트
titanic_df.groupby(['Sex', 'Survived'])['Survived'].count() # 성별과 생존자별 빈도 수 출력

# 성별 생존 확률을 그래프로 표현
sns.barplot(x='Sex', y='Survived', data=titanic_df) # 여성과 남성의 생존자 수 막대그래프 비교

# 객실등급별 성별 생존 확률을 그래프로 표현
sns.barplot(x='Pclass', y='Survived', hue='Sex', data=titanic_df) # 등급별 생존률 비교

# age에 따른 생존 확율을 확인하기 위해 age 컬럼의 값을
# 명목형으로 binning하기 위한 함수 생성
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

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

# get_category(X)는 입력값으로 'Age' 컬럼값을 받아서 해당하는 cat 반환
titanic_df['Age_cat'] = titanic_df['Age'].apply(lambda x: get_category(x))

titanic_df.info()

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

sns.barplot(x='Age_cat', y='Survived', hue='Sex', data=titanic_df, order=group_names)

titanic_df.drop('Age_cat', axis=1, inplace=True)


### 데이터 전처리에 사용할 사용자 정의 함수들 생성

# 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 df


# 머신러닝 알고리즘에 불필요한 속성 제거
def drop_features(df):
    df.drop(['PassengerId', 'Name', 'Ticket'], axis=1, inplace=True)
    return df


# 문자열 값을 숫자형 값으 Encoding하는 함수
def format_features(df):
    df['Cabin'] = df['Cabin'].str[:1]
    features = ['Cabin', 'Sex', 'Embarked']
    for feature in features:
        le = LabelEncoder()
        le = le.fit(df[feature])
        df[feature] = le.transform(df[feature])
    return df


# 앞에서 설정한 Data Preprocessing 함수들을 호출하는 함수
def transform_features(df):
    df = fillna(df)
    df = drop_features(df)
    df = format_features(df)
    return df


### 원본 데이터를 재로딩

# 데이터 로딩
titanic_df = pd.read_csv("D://pythonclass//train.csv")

# feature 데이터 셋과 Label 데이터 셋 분리
y_titanic_df = titanic_df['Survived']
X_titanic_df = titanic_df.drop('Survived', axis=1)
X_titanic_df = transform_features(X_titanic_df)

# Training set과 Testing set 분리
X_train, X_test, y_train, y_test = train_test_split(X_titanic_df, y_titanic_df, test_size=0.2, random_state=11)

# Decision Tree, Random Forest, Logistic Regression을 적용하기 위한 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('LogisticRegression 정확도: {0:.4f}'.format(accuracy_score(y_test, lr_pred)))

### Cross Validation

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 호출
exec_kfold(dt_clf, folds=5)

scores = cross_val_score(dt_clf, X_titanic_df, y_titanic_df, cv=5)

for iter_count, accuracy in enumerate(scores):
    print("교차 검증 {0} 정확도: {1:.4f}".format(iter_count, accuracy))

print("평균 정확도: {0:.4f}".format(np.mean(scores)))


parameters = {'max_depth': [2, 3, 5, 10],
              'min_samples_split': [2, 3, 5],
              'min_samples_leaf': [1, 5, 8]}

grid_dclf = GridSearchCV(dt_clf,
                         param_grid=parameters,
                         scoring='accuracy',
                         cv=5)

grid_dclf.fit(X_train, y_train)

print('GridSearchCV 최적 하이퍼 파라미터 :', grid_dclf.best_params_)
print('GridSearchCV 최고 정확도: {0:.4f}'.format(grid_dclf.best_score_))
best_dclf = grid_dclf.best_estimator_

# GridSearchCV의 최적 하이퍼 파라미터로 학습된 Estimator로 예측 및 평가 수행.
dpredictions = best_dclf.predict(X_test)
accuracy = accuracy_score(y_test, dpredictions)

print('테스트 세트에서의 DecisionTreeClassifier 정확도 : {0:.4f}'.format(accuracy))