모델의 평가

# 캐글 타이타닉 데이터셋에서 사망자 분포 확인
import pandas as pd
%matplotlib inline
import matplotlib.pyplot as plt
import seaborn as sns

titanic_df = pd.read_csv('Titanic/input/train.csv')

sns.countplot(data = titanic_df, x = 'Survived', hue = 'Sex')
plt.title('Number of Survived with Sex')
plt.show()

import numpy as np

# fit() 메서드는 아무 것도 수행하지 않고
# predict()는 Sex가 1이면 0, 그렇지 않으면 1로 예측하는 단순한 분류기 생성
from sklearn.base import BaseEstimator

class DummyClassifier(BaseEstimator):
  def fit(self, X, y = None):
    pass
  
  def predict(self, X):
    pred = np.zeros((X.shape[0],1))
    for i in range(X.shape[0]):
      if X['Sex'].iloc[i] == 1:
        pred[i] = 0
      else:
        pred[i] = 1
    return pred

# 생성된 DummyClassifier를 이용해 타이타닉 예제 생존자 예측 수행
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from sklearn.preprocessing import LabelEncoder

# 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_feature(df):
  df.drop(['PassengerId', 'Name', 'Ticket'], axis = 1, inplace = True)
  return df

# LabelEncoder 수행
def format_feature(df):
  df['Cabin'] = df['Cabin'].str[:1]
  features = ['Cabin', 'Sex', 'Embarked']
  for feature in features:
    label_encoder = LabelEncoder()
    label_encoder.fit(df[feature])
    df[feature] = label_encoder.transform(df[feature])
  return df

# 위의 함수들을 한꺼번에 실행하는 함수
def transform_features(df):
  df = fillna(df)
  df = drop_feature(df)
  df = format_features(df)
  return df

# 타이타닉 데이터 로딩 및 학습 데이터 / 테스트 데이터 분할
y_titanic_df = titanic_df['Survived']
X_titanic_df = titanic_df.drop(['Survived'], axis = 1)
X_titanic_df = transform_features(X_titanic_df)

X_train, X_test, y_train, y_test = train_test_split(X_titanic_df, 
                                                    y_titanic_df,
                                                    test_size = 0.2,
                                                    random_state = 10)

# 위에서 생성한 Dummy Classifier를 활용해서 학습/예측/평가 수행
model = DummyClassifier()
model.fit(X_train, y_train)

predictions = model.predict(X_test)
print('Dummy Classifier의 정확도: {0: .4f}'.format(accuracy_score(y_test, predictions)))

# DummyClassifier를 이용하여 예측한 결과와 y_test를 비교하여 혼동행렬 출력하기
from sklearn.metrics import confusion_matrix

cm = confusion_matrix(y_test, predictions)
print(cm)
print('')
print('True Negative : ' , cm[0][0], ' → 사망자(0)를 사망자(0)로 예측')
print('False Positive : ', cm[0][1], '→ 사망자(0)인데 생존자(1)로 예측')
print('False Negative : ', cm[1][0], ' → 생존자(1)인데 사망자(0)로 예측')
print('True Positive: ', cm[1][1], '→ 생존자(1)를 생존자(1)로 예측')

from sklearn.metrics import accuracy_score, precision_score, recall_score, confusion_matrix

# 호출한 지표들을 한꺼번에 계산하는 함수 정의
def get_clf_eval(y_test, pred):
    confusion = confusion_matrix(y_test, pred)
    accuracy = accuracy_score(y_test, pred)
    precision = precision_score(y_test, pred)
    recall = recall_score(y_test, pred)
    print('오차행렬')
    print(confusion)
    print('')
    print('정확도 : {:.4f}'.format(accuracy))
    print('정밀도 : {:.4f}'.format(precision))
    print('재현율 : {:.4f}'.format(recall))

from sklearn.linear_model import LogisticRegression

titanic_df = pd.read_csv('Titanic/input/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)

X_train, X_test, y_train, y_test = train_test_split(X_titanic_df,
                                                    y_titanic_df,
                                                    test_size = 0.2,
                                                    random_state = 10)

clf = LogisticRegression()
clf.fit(X_train, y_train)
pred = clf.predict(X_test)
get_clf_eval(y_test, pred)

# 타이타닉 생존자 데이터에서 predict() 결과 값과 predict_proba()결과값을 비교하기
pred_proba = clf.predict_proba(X_test)
pred = clf.predict(X_test)

print('pred_proba의 shape: {}'.format(pred_proba.shape))
print('pred_proba의 array의 앞 5개만 샘플로 추출:\n', pred_proba[:5])
# 예측확률 array와 예측결과값 array를 병합하여 예측확률과 결과값을 한 번에 확인하기
pred_proba_result = np.concatenate([pred_proba, pred.reshape(-1, 1)], axis=1)
print('두 개의 레이블 중 더 큰 확률을 클래스 값으로 예측: \n', pred_proba_result[:5])

from sklearn.preprocessing import Binarizer

# 예시
X = [[-1, -1, 2],
     [2, 0, 0], 
     [0, 1.1, 1.2]]

# X의 개별원소들이 threshold보다 크면 1, 작거나 같으면 0을 반환
binarizer = Binarizer(threshold=1.1)
print(binarizer.fit_transform(X))

# 임계값
thresholds = [0.4, 0.45, 0.5, 0.55, 0.6]

# 임계치에 따른 평가지표를 조사하기 위한 함수 생성
def get_eval_by_threshold(y_test, pred_proba_c1, thresholds):
    for custom_threshold in thresholds:
        binarizer = Binarizer(threshold=custom_threshold)
        custom_predict = binarizer.fit_transform(pred_proba_c1)
        print('임계값: ', custom_threshold)
        get_clf_eval(y_test, custom_predict)
        print('---------------')

pred_proba = clf.predict_proba(X_test)
get_eval_by_threshold(y_test, pred_proba[:,1].reshape(-1,1), thresholds)

import matplotlib.pyplot as plt
%matplotlib inline
from sklearn.metrics import precision_recall_curve

def precision_recall_curve_plot(y_test, predict_proba_c1):
    # 정밀도, 재현율, 임계값을 ndarray로 추출하기
    precisions, recalls, thresholds = precision_recall_curve(y_test, predict_proba_c1)
    
    # x축을 임계값, y축을 정밀도, 재현율로 그래프 그리기
    plt.figure(figsize = (8, 6))
    thresholds_boundary = thresholds.shape[0]
    # 정밀도와 재현율은 임계값보다 1개 적게 반환되기 때문에 슬라이싱을 해주어야 합니다.
    plt.plot(thresholds, precisions[:thresholds_boundary], 
             linestyle = '--', label='precision')
    plt.plot(thresholds, recalls[:thresholds_boundary], 
             linestyle = '-', label = 'recall')
    
    # x축의 scale을 0.1 단위로 변경
    plt.xticks(np.round(np.arange(0, 1, 0.1),2))
    plt.xlabel('thresholds')
    plt.ylabel('precision(recall)')
    
    plt.legend()
    plt.grid()
    plt.show()
    
precision_recall_curve_plot(y_test, clf.predict_proba(X_test)[:, 1])

from sklearn.linear_model import LogisticRegresion

titanic_df = pd.read_csv('Titanic/input/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)

X_train, X_test, y_train, y_test = train_test_split(X_titanic_df,
                                                    y_titanic_df,
                                                    test_size = 0.2,
                                                    random_state = 10)

clf = LogisticRegression()
clf.fit(X_train, y_train)
pred = clf.predict(X_test)

# f1 score를 계산하기
from sklearn.metrics import precision_score, recall_score, f1_score
precision = precision_score(y_test, pred)
recall = recall_score(y_test, pred)
f1 = f1_score(y_test, pred)

print('정밀도(Precision) : {:.4f}'.format(precision))
print('재현율(Recall) : {:.4f}'.format(recall))
print('F1 : {:.4f}'.format(f1))

# 예측결과에 따른 평가지표 계산
def get_clf_eval(y_test, pred):
    confusion = confusion_matrix(y_test, pred)
    accuracy = accuracy_score(y_test, pred)
    precision = precision_score(y_test, pred)
    recall = recall_score(y_test, pred)
    f1 = f1_score(y_test, pred)
    print('오차행렬')
    print(confusion)
    # F1 score print 추가
    print('\n정확도: {:.4f}\n정밀도: {:.4f}\n재현율: {:.4f}\nF1: {:.4f}'.format(accuracy, precision, recall, f1))

# 임계값에 따른 평가지표 계산    
def get_eval_by_threshold(y_test, pred_proba_c1, thresholds):
    for custom_threshold in thresholds:
        binarizer = Binarizer(threshold=custom_threshold)
        custom_predict = binarizer.fit_transform(pred_proba_c1)
        print('임계값: ', custom_threshold)
        get_clf_eval(y_test, custom_predict)
        print('---------------')
    
thresholds = [0.4, 0.45, 0.5, 0.55, 0.6]
pred_proba = clf.predict_proba(X_test)
get_eval_by_threshold(y_test, pred_proba[:,1].reshape(-1, 1), thresholds)

import matplotlib.pyplot as plt
%matplotlib inline
from sklearn.metrics import precision_recall_curve

def precision_recall_curve_plot(y_test, predict_proba_c1):
    # 정밀도, 재현율, 임계값을 ndarray로 추출하기
    precisions, recalls, thresholds = precision_recall_curve(y_test, predict_proba_c1)
    f1 = 2 * (precisions * recalls) / (precisions + recalls)
    
    # x축을 임계값, y축을 정밀도, 재현율로 그래프 그리기
    plt.figure(figsize = (8, 6))
    thresholds_boundary = thresholds.shape[0]
    # 정밀도와 재현율은 임계값보다 1개 적게 반환되기 때문에 슬라이싱을 해주어야 합니다.
    plt.plot(thresholds, precisions[:thresholds_boundary], 
             linestyle = '--', label='precision')
    plt.plot(thresholds, recalls[:thresholds_boundary], 
             linestyle = '-', label = 'recall')
    plt.plot(thresholds, f1[:thresholds_boundary], 
             linestyle = ':',  label = 'f1')
    
    # x축의 scale을 0.1 단위로 변경
    plt.xticks(np.round(np.arange(0, 1, 0.1),2))
    plt.xlabel('thresholds')
    plt.ylabel('score')
    
    plt.legend()
    plt.grid()
    plt.show()
    
pred_proba = clf.predict_proba(X_test)
precision_recall_curve_plot(y_test, pred_proba[:, 1])

from sklearn.metrics import roc_curve

# 레이블 값이 1일 때 예측 확률을 추출
pred_proba_class1 = clf.predict_proba(X_test)[:, 1]

fpr, tpr, thresholds = roc_curve(y_test, pred_proba_class1)

# 반환된 임계값 중 샘플로 10건만 추출하되 임계값을 5 step으로 추출
thr_index = np.arange(1, thresholds.shape[0], 5)
print('샘플 추출된 임계값 배열의 index 10개: ', thr_index)
print('샘플용 10개의 임계값: ', np.round(thresholds[thr_index], 2))

# 샘플로 추출된 임계값에 따른 FPR, TPR 값
print('샘플 임계값별 FPR: ', np.round(fpr[thr_index], 3))
print('샘플 임계값별 TPR: ', np.round(tpr[thr_index], 3))

# ROC 곡선의 시각화
def roc_curve_plot(y_test, pred_proba_c1):
    #임계값에 따른 FPR, TPR 값을반환 받음
    fprs, tprs, thresholds  = roc_curve(y_test, pred_proba_c1)
    # ROC곡선을 그래프로 그림
    plt.plot(fprs, tprs, label='ROC')
    # 가운데 대각선 직선을 그림
    plt.plot([0,1], [0,1], 'k--', label='Random')
    
    # FPR X축의 Scale을 0.1 단위로 변경, X, Y축 명 설정 등
    start, end = plt.xlim()
    plt.xticks(np.round(np.arange(start, end, 0.1), 2))
    plt.xlim(0, 1)
    plt.ylim(0, 1)
    plt.xlabel('FPR(1-Sensitivity)')
    plt.ylabel('TPR(Recall)')
    plt.legend()
    
roc_curve_plot(y_test, pred_proba[:, 1])

from sklearn.metrics import roc_auc_score

pred = clf.predict(X_test)
roc_score = roc_auc_score(y_test, pred)
print('ROC AUC 값 : {:.4f}'.format(roc_score))