스터디노트 (credit card data 1)

📌 신용카드 부정 사용자 검출해보기

🔻Data import

→ 신용카드 불량 사용자 비율이 매우 낮다 (0.17%..)비율이 낮다는 것은? 데이터가 매우 불균형한 상태라는 것.

import pandas as pd

raw_data = pd.read_csv('../data/creditcard.csv')
raw_data.head()

raw_data['Class'].value_counts()
>>>>
Class
0    284315
1       492
Name: count, dtype: int64

frauds_rate = round(raw_data['Class'].value_counts()[1] / len(raw_data) * 100,2)
frauds_rate
>>>>
0.17

🔻Data를 plot으로 그려보기

import seaborn as sns
import matplotlib.pyplot as plt

sns.countplot(x='Class', data = raw_data)
plt.title('Class Distribution')
plt.show()

잘 안보이겠지만.. 1이 불량률이다.

🔻train data의 비율 확인

from sklearn.model_selection import train_test_split

X = raw_data.iloc[:, 1:-1] # column V1 ~ amount 까지
y = raw_data.iloc[:, -1] # 마지막 컬럼만 선택 (Class)

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state= 13, stratify=y)

import numpy as np
np.unique(y_train, return_counts=True)
>>>>
(array([0, 1], dtype=int64), array([227451,    394], dtype=int64))

# 데이터의 불균형 정도가 어떤지 확인
tmp = np.unique(y_train, return_counts=True)[1]
tmp[1] / len(y_train) * 100
>>>>
0.17292457591783889

📌 다양한 시도를 해보기

🔻def 생성

# 분류기의 성능을 return하는 함수 
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, roc_auc_score

def get_clf_eval(y_test, pred):
    acc = accuracy_score(y_test, pred)
    pre = precision_score(y_test, pred)
    re = recall_score(y_test, pred)
    f1 = f1_score(y_test, pred)
    auc = roc_auc_score(y_test, pred)

    return acc, pre, re, f1, auc

# 성능을 출력하는 함수 작성
from sklearn.metrics import confusion_matrix

def print_clf_eval(y_test, pred):
    confusion = confusion_matrix(y_test, pred)
    acc, pre, re, f1, auc = get_clf_eval(y_test, pred)

    print('confusion metrix')
    print(confusion)
    print('----------------')

    print('Accuracy : {0:.4f}, precision : {1:.4f}'. format(acc, pre))
    print('recall : {0:.4f}, f1_score : {1:.4f}, auc : {2:.4f}'. format(re, f1, auc))

---

🔻로지스틱 회귀 실행 해보기

→ 56,864 개의 0 (정상 data) 중에서 8개를 fraud로 오인

→ 98개의 1 (불량 data) 중에서 40개를 정상으로 오인

→ Accuracy는 99.92% 이지만, Recall 수치는 59%로 결과가 좋지 않다 (불량인 데이터 중, 진짜 불량을 감지해내는 비율이 59%)

from sklearn.linear_model import LogisticRegression

lr_clf = LogisticRegression(random_state=13, solver='liblinear')
lr_clf.fit(X_train, y_train)
lr_pred = lr_clf.predict(X_test)

print_clf_eval(y_test, lr_pred)
>>>>
confusion metrix
[[56856     8]
 [   40    58]]
----------------
Accuracy : 0.9992, precision : 0.8788
recall : 0.5918, f1_score : 0.7073, auc : 0.7958

🔻결정나무 실행 해보기

→ 56,864 개의 0 (정상 data) 중에서 8개를 fraud로 오인

→ 98개의 1 (불량 data) 중에서 33개를 정상으로 오인 (recall 66%)

from sklearn.tree import DecisionTreeClassifier

dt_clf = DecisionTreeClassifier(random_state=13, max_depth=4)
dt_clf.fit(X_train, y_train)
dt_pred = dt_clf.predict(X_test)

print_clf_eval(y_test, dt_pred)
>>>>
confusion metrix
[[56856     8]
 [   33    65]]
----------------
Accuracy : 0.9993, precision : 0.8904
recall : 0.6633, f1_score : 0.7602, auc : 0.8316

🔻랜덤포레스트로 실행 해보기

→ 56,864 개의 0 (정상 data) 중에서 7개를 fraud로 오인

→ 98개의 1 (불량 data) 중에서 25개를 정상으로 오인 (recall 74%)

→ 점점 성능이 괜찮아 지는 것 같다

from sklearn.ensemble import RandomForestClassifier

rf_clf = RandomForestClassifier(random_state=13, n_jobs=-1, n_estimators=100)
rf_clf.fit(X_train, y_train)
rf_pred = rf_clf.predict(X_test)

print_clf_eval(y_test, rf_pred)
>>>>
confusion metrix
[[56857     7]
 [   25    73]]
----------------
Accuracy : 0.9994, precision : 0.9125
recall : 0.7449, f1_score : 0.8202, auc : 0.8724

🔻LGBM으로 실행해보기

→ 56,864 개의 0 (정상 data) 중에서 6개를 fraud로 오인

→ 98개의 1 (불량 data) 중에서 24개를 정상으로 오인 (recall 75%)

→ 랜덤 포레스트와 큰 차이는 없는 듯..

from lightgbm import LGBMClassifier

lgbm_clf = LGBMClassifier(random_state=13, n_jobs=-1, n_estimators=1000, num_leaves=64, boost_from_average=False)
lgbm_clf.fit(X_train, y_train)
lgbm_pred = lgbm_clf.predict(X_test)

print_clf_eval(y_test, lgbm_pred)
>>>>
confusion metrix
[[56858     6]
 [   24    74]]
----------------
Accuracy : 0.9995, precision : 0.9250
recall : 0.7551, f1_score : 0.8315, auc : 0.8775

---

🔻결과를 DataFrame 으로 !

def get_result(model, X_train, y_train, X_test, y_test):
    model.fit(X_train, y_train)
    pred = model.predict(X_test)

    return get_clf_eval(y_test, pred)

import pandas as pd

def get_result_pd(models, model_names, X_train, y_train, X_test, y_test):
    col_names = ['accuracy', 'precision', 'recall', 'f1', 'roc_auc']
    tmp = []

    for model in models:
        tmp.append(get_result(model, X_train, y_train, X_test, y_test))
    
    return pd.DataFrame(tmp, columns=col_names, index=model_names)

🔻결과를 데이터 프레임으로!

→ Accuracy는 매우 높다

→ Recall 성능은 RandomForest, LGBM의 성능이 좋아보인다.

models = [lr_clf, dt_clf, rf_clf, lgbm_clf]
model_names = ['Logistic Regression', 'DecisionTree', 'RandomForest', 'LightGBM']
result = get_result_pd(models, model_names, X_train, y_train, X_test, y_test)
result