[pythonML] 머신러닝으로 타이타닉 생존자 예측

#정리

1. 데이터의 가공 및 변환 과정의 전처리 (결손값 처리, 인코딩 작업, 스케일링/정규화 작업)

2. 데이터를 학습 데이터와 테스트 데이터로 분리하는 데이터 세트 분리 (한쪽 데이터에 치우칠때 => 교차검증)

3. 학습 데이터를 기반으로 머신러닝 알고리즘을 적용해 모델을 학습

4. 학습된 모델을 기반으로 테스트 데이터에 대한 예측 수행

5. 예측된 결괏값을 실제 결괏값과 비교해 머신러닝 모델에 대한 평가를 수행

 

1.  데이터 전처리

from sklearn.preprocessing import LabelEncoder

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

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

# 레이블 인코딩 수행. 
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

# 원본 데이터를 재로딩 하고, feature데이터 셋과 Label 데이터 셋 추출. 
titanic_df = pd.read_csv('titanic_train.csv')

y_titanic_df = titanic_df['Survived'] #Label 데이터 셋
X_titanic_df= titanic_df.drop('Survived',axis=1) #feature데이터 셋 (Survived 컬럼을 제외한)

X_titanic_df = transform_features(X_titanic_df) #feature데이터셋에 데이터전처리를 하는 코드임

2. 학습/테스트 분리

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,

 

3. 학습/예측/평가

결정트리, 랜덤 포레스트, 로지스틱 회귀를 이용해 예측

예측 성능 평가는 정확도

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) #Random Forest
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))) #평가

DecisionTreeClassifier 정확도: 0.7877
RandomForestClassifier 정확도:0.8547
LogisticRegression 정확도: 0.8492

RandomForestClassifier 정확도:0.8547 로 가장 높은 정확도를 나타냄

 

 

4-1. 교차검증 KFold

의사결정나무에 대해 5 KFold 실행

from sklearn.model_selection import KFold

def exec_kfold(clf, folds=5): #폴드 개수 : 5개 (폴드 수만큼 예측결과 저장을 위한  리스트 객체 생성.)
    kfold = KFold(n_splits=folds)
    scores = []
    
    # <KFold 교차 검증>                         # kfold.split : 폴드 별 학습,검증용 테스트의 로우 인덱스를 array로 변환
    for iter_count , (train_index, test_index) in enumerate(kfold.split(X_titanic_df)):
                        #.values를 함으로서 array로 X_titanic_df, y_titanic_df가 변환됨
        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)

교차 검증 0 정확도: 0.7542
교차 검증 1 정확도: 0.7809
교차 검증 2 정확도: 0.7865
교차 검증 3 정확도: 0.7697
교차 검증 4 정확도: 0.8202
평균 정확도: 0.7823

평균 정확도 : 0.7823

 

4-2 교차검증 cross_val_score (StratifiedKFold)

의사결정나무에 대해 cross_val_score 실행

from sklearn.model_selection import cross_val_score
        #cross_val_score(어떤방식, data, label, cv= )
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)))

교차 검증 0 정확도: 0.7430
교차 검증 1 정확도: 0.7753
교차 검증 2 정확도: 0.7921
교차 검증 3 정확도: 0.7865
교차 검증 4 정확도: 0.8427
평균 정확도: 0.7879

평균 정확도 : 0.7879

 

4-3 교차검증 GridSearchCV

의사결정나무에 대해 GridSearchCV 실행

from sklearn.model_selection import GridSearchCV

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))

GridSearchCV(cv=5, estimator=DecisionTreeClassifier(random_state=11),
             param_grid={'max_depth': [2, 3, 5, 10],
                         'min_samples_leaf': [1, 5, 8],
                         'min_samples_split': [2, 3, 5]},
             scoring='accuracy')
             
GridSearchCV 최적 하이퍼 파라미터 : {'max_depth': 3, 'min_samples_leaf': 5, 'min_samples_split': 2}
GridSearchCV 최고 정확도: 0.7992
테스트 세트에서의 DecisionTreeClassifier 정확도 : 0.8715

정확도 : 0.8715

 

1. DecisionTreeClassifier 정확도: 0.7877

2. 교차검증 KFold 평균 정확도 : 0.7823

3. 교차검증 cross_val_score   평균 정확도 : 0.7879

4. 교차검증 GridSearchCV 정확도 : 0.8715

=> 점점 증가 확인 가능