2. Tabular 데이터 모델링 (머신러닝)

머신러닝 모델 프로세스

1. 라이브러리 임포트
2. 데이터 가져오기
3. 데이터 분석
4. 데이터 전처리
5. Train, Test 데이터셋 분할 
6. 데이터 정규화
7. 모델 구현
   • 단일 분류 예측 모델 : LogisticRegression, KNN, Decision Tree
   • 앙상블 모델 : RandomForest, XGBoost, LGBM
8. 모델 성능 평가

---

1. 라이브러리 임포트 

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

2. 데이터 가져오기

df = pd.read_csv('data.csv') # data.csv 파일을 읽어와서 df 변수에 저장

3. 데이터 분석

df.info() # index, 컬럼명, Non-Null Count, Dtype
df.head() # 앞에서 5개 컬럼 보여줌
df.tail() # 뒤에서 5개 컬럼 보여줌

4. 데이터 전처리

• 모든 데이터 값은 숫자형이어야 함, Object 타입 -> 숫자형 변경
• Object 컬럼에 대해 Pandas get_dummies 함수 활용하여 One-Hot Encoding

pd.get_dummies(data=df, columns=['컬럼명']) # 해당 컬럼 원핫인코딩

col = df.select_dtypes('object').columns.values
df1 = pd.get_dummies(data=df, columns=cols) # object형 컬럼 원핫인코딩

5. Train, Test 데이터셋 분할

from sklearn.model_selection import train_test_split

X = df1.drop('컬럼1')
y = df1['컬럼1'].values # 예측할 값

X_train, X_test, y_train, y_test = train_test_split(X,y,
                                                    test_size=0.3, # train/test 비율
                                                    stratify=y, # y class 비율에 맞게 나누기
                                                    random_state=42) # 여러번 수행해도 같은 결과 나오게 고정

6. 데이터 정규화 / 스케일링

from sklearn.preprocessing import MinMaxScaler

scaler = MinMaxScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)

7. 모델 개발

머신러닝은 대체로 4가지 순서로 진행됨
1. 임포트
2. 모델 정의
3. fit 학습
4. 예측  

1) Logistic Regression (로지스틱 회귀)

from sklearn.linear_model import LogisticRegression
# 함수 사용 및 정의, 학습
lg = LogisticRegression()
lg.fit(X_train, y_train)
# 성능평가
lg.score(X_test, y_test)

+ 분류기 성능 평가 지표

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

lg.score(X_test, y_test)
lg_pred = lg.predict(X_test)

# 오차행렬
confusion_matrix(y_test, lg_pred)
# 정확도
accuracy_score(y_test, lg_pred)
# 정밀도
precision_score(y_test, lg_pred)
# 재현율
recall_score(y_test, lg_pred)
# f1 score (정밀도+재현율)
f1_score(y_test, lg_pred)

# classification report 출력하기
print(classification_report(y_test, lg_pred))

2) KNN (K-Nearest Neighbor)

from sklearn.neighbors import KNeighborsClassifier

knn = KNeighborsClassifier(n_neighbors=5)
knn.fit(X_train, y_train)
knn_pred = knn.predict(X_test)

3) Decision Tree (결정 트리)

from sklearn.tree import DecisionTreeClassifier

dt = DecisionTreeClassifier(max_depth=10, random_state=42)
dt.fit(X_train,y_train)
dt_pred = dt.predict(X_test)

 

여기부터는 앙상블 기법

• 배깅 (Bagging): 여러 개의 DecisionTree 활용하고 샘플 중복 생성을 통해 결과 도출 (RandomForest)
• 부스팅 (Boosting): 약한 학습기를 순차적으로 학습을 하되, 이전 학습에 대하여 잘못 예측된 데이터에 가중치를 부여해 오차를 보완해 나가는 방식 (XGBoost, LGBM)

4) RandomForest

from sklearn.ensemble import RandomForestClassifier
# n_estimators: 앙상블하는 트리의 갯수
# random_state: 랜덤 시드 고정 값. 고정해두고 튜닝해야 함
# n_jobs: CPU 사용 갯수
# max_depth: 깊어질 수 있는 최대 깊이. 과대적합 방지용
# max_features: 최대로 사용할 feature의 갯수. 과대적합 방지용
# min_samples_split: 트리가 분할할 때 최소 샘플의 갯수. default=2. 과대적합 방지용
rfc = RandomForestClassifier(n_estimators = 3, random_state = 42)
rfc.fit(X_train, y_train)
rfc_pred = rfc.predict(X_test)

5) XGBoost

!pip install xgboost

from xgboost import XGBClassifier
# n_estimators: 부스팅 스테이지 수. (랜덤포레스트 트리의 갯수 설정과 비슷한 개념). default=100
# random_state: 랜덤 시드 고정 값. 고정해두고 튜닝할 것!
# n_jobs: CPU 사용 갯수
# learning_rate: 학습율. 너무 큰 학습율은 성능을 떨어뜨리고, 너무 작은 학습율은 학습이 느리다. 적절한 값을 찾아야함. n_estimators와 같이 튜닝. default=0.1
# max_depth: 트리의 깊이. 과대적합 방지용. default=3. 
# max_features: 최대로 사용할 feature의 비율. 과대적합 방지용. default=1.0
# subsample: 샘플 사용 비율. 과대적합 방지용. default=1.0
xgb = XGBClassifier(n_estimators=3, random_state=42)  
xgb.fit(X_train, y_train)
xgb_pred = xgb.predict(X_test)

6) Light GBM (LGBM)

!pip install lightgbm

from lightgbm import LGBMClassifier
# n_estimators: 부스팅 스테이지 수. (랜덤포레스트 트리의 갯수 설정과 비슷한 개념). default=100
# random_state: 랜덤 시드 고정 값. 고정해두고 튜닝할 것!
# n_jobs: CPU 사용 갯수
# learning_rate: 학습율. 너무 큰 학습율은 성능을 떨어뜨리고, 너무 작은 학습율은 학습이 느리다. 적절한 값을 찾아야함. n_estimators와 같이 튜닝. default=0.1
# max_depth: 트리의 깊이. 과대적합 방지용. default=3. 
# colsample_bytree: 샘플 사용 비율 (max_features와 비슷한 개념). 과대적합 방지용. default=1.0
lgbm = LGBMClassifier(n_estimators=3, random_state=42)  
lgbm.fit(X_train, y_train)
lgbm_pred = lgbm.predict(X_test)

 

+ 성능 그래프 그리기

recall_eval('LogisticRegression', lg_pred, y_test)
recall_eval('K-Nearest Neighbor', knn_pred, y_test)
recall_eval('DecisionTree', dt_pred, y_test)
recall_eval('RandomForest', rfc_pred, y_test)
recall_eval('XGBoost', xgb_pred, y_test)
recall_eval('LGBM', lgbm_pred, y_test)

 

---

 

헷갈리는 코드 정리

    - df['컬럼명'].value_counts().plot(kind='bar') : 판다스 value_counts와 plot 함수로 컬럼 불균형 확인하기  
    - pd.get_dummies(data = df, columns=['컬럼명']) : 판다스 get_dummies 함수 이용해서 컬럼 값을 원핫 인코딩 출력
    - df.select_dtypes('object').head() : select_dtypes 함수 이용해서 Object 컬럼 확인
    - cal_cols = df.select_dtypes('object').columns.values : 판다스 select_dtypes 함수 이용해서 Object 컬럼 명의 값(values) 수집, cal_cols에 저장하기

    - X = df1.drop('컬럼', axis = 1).values : df1 데이터프레임에서 컬럼 삭제 및 values만 X에 저장  
    - X.shape, y.shape : X, y 데이터에 대한 shape 확인하기
    - from sklearn.model_selection import train_test_split : sklearn.model_selection 하위에 있는 train_test_split 임포트
    - train_test_split test_size-0.3 옵션 : Train, Test 비율 7,3으로 나누기
    - train_test_split stratify 옵션 : 계층적 데이터 추출 옵션

    - from sklearn.preprocessing import MinMaxScaler : MinMaxScaler 함수 임포트 (sklearn.preprocessing 모듈 밑에 있음)
    - X_train = scaler.fit_transform(X_train) / X_test = scaler.transform(X_test) : X_train, X_test에 scaler(MinMaxScaler() 사용)

    - lg.score(X_test,y_test) : logistic regression 성능 평가 (test 데이터 넣어야 함)
    - lg_pred = lg.predict(X_test) : 예측 결과를 lg_pred에 저장
    - print(classification_report(y_test, lg_pred)) : classification_report 출력 -> precision, recall, f1-score

    - knn_pred = knn.predict(X_test) : X_test 예측 결과 knn_pred에 저장