본문 바로가기

파이썬

12-3. 머신러닝 분류모델 총정리(이패스 신성진 김용재 와 함께하는 AI모델링)

머신러닝 지도학습 분류모델 (데이터 불러오기, 전처리) - 일반분할

이패스 신성진 김용재 와 함께하는 AI모델링

# 📌 머신러닝 지도학습 모델 - 분류모델 총정리 (Heart 데이터 활용)
# - 일반 Train/Test Split을 사용 (K-Fold 분할은 주석으로 설명)
# - 각 모델의 하이퍼파라미터를 상세히 설명

import pandas as pd
from sklearn.model_selection import train_test_split, KFold, cross_val_score
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, roc_auc_score, confusion_matrix

# 1️⃣ 데이터 불러오기 및 전처리
heart_data = pd.read_csv("datasets/heart.csv")

# X (특성)과 y (타겟) 분리
X_heart = heart_data.drop(columns=["output"])  # 'output' 열 제거
y_heart = heart_data["output"]  # 'output' 열을 타겟 변수로 설정

# 데이터 정규화
scaler = StandardScaler()
X_heart_scaled = scaler.fit_transform(X_heart)

# Train/Test Split (K-Fold 사용 시 아래 코드 대신 KFold 적용 가능)
X_train_h, X_test_h, y_train_h, y_test_h = train_test_split(X_heart_scaled, y_heart, test_size=0.2, random_state=42)

# K-Fold 교차 검증을 사용하려면 아래 코드 활용 (현재 주석)
# kf = KFold(n_splits=5, shuffle=True, random_state=42)
# cross_val_score(estimator, X_heart_scaled, y_heart, cv=kf, scoring="accuracy")

 

머신러닝 지도학습 분류모델 (모델별 학습 및 평가) - 일반분할

# 📌 2️⃣ Logistic Regression (로지스틱 회귀)

from sklearn.linear_model import LogisticRegression

# LogisticRegression 모델 생성
log_reg = LogisticRegression(
    max_iter=1000,  # 최대 반복 횟수 (기본값 100, 과적합 방지를 위해 증가 가능)
    solver='lbfgs',  # 최적화 알고리즘 ('liblinear'는 작은 데이터셋에서 추천)
    C=1.0,  # 규제 강도 (작을수록 강한 규제, 기본값 1.0)
    random_state=42
)

# 모델 학습
log_reg.fit(X_train_h, y_train_h)

# 예측
y_pred_log = log_reg.predict(X_test_h)

# 성능 평가
print("Logistic Regression Accuracy:", accuracy_score(y_test_h, y_pred_log))
print("Precision:", precision_score(y_test_h, y_pred_log))
print("Recall:", recall_score(y_test_h, y_pred_log))
print("F1 Score:", f1_score(y_test_h, y_pred_log))
print("ROC AUC Score:", roc_auc_score(y_test_h, y_pred_log))
print("Confusion Matrix:\n", confusion_matrix(y_test_h, y_pred_log))



# 📌 3️⃣ Decision Tree (의사결정 나무)

from sklearn.tree import DecisionTreeClassifier

# DecisionTreeClassifier 모델 생성
dt = DecisionTreeClassifier(
    max_depth=5,  # 트리의 최대 깊이 (기본값 None, 과적합 방지를 위해 설정 가능)
    criterion='gini',  # 불순도 측정 방법 ('entropy'도 사용 가능)
    min_samples_split=2,  # 노드를 분할하기 위한 최소 샘플 수
    min_samples_leaf=1,  # 리프 노드가 가져야 할 최소 샘플 수
    random_state=42
)

# 모델 학습
dt.fit(X_train_h, y_train_h)

# 예측
y_pred_dt = dt.predict(X_test_h)

# 성능 평가
print("Decision Tree Accuracy:", accuracy_score(y_test_h, y_pred_dt))
print("Precision:", precision_score(y_test_h, y_pred_dt))
print("Recall:", recall_score(y_test_h, y_pred_dt))
print("F1 Score:", f1_score(y_test_h, y_pred_dt))
print("ROC AUC Score:", roc_auc_score(y_test_h, y_pred_dt))
print("Confusion Matrix:\n", confusion_matrix(y_test_h, y_pred_dt))


# 📌 4️⃣ SVM (Support Vector Machine)

from sklearn.svm import SVC

# SVC 모델 생성
svm = SVC(
    kernel="linear",  # 커널 유형 ('linear', 'rbf', 'poly' 등 선택 가능)
    C=1.0,  # 규제 강도 (값이 작을수록 규제가 강해지고 과적합 방지)
    probability=True,  # 확률 예측 활성화 (계산 비용 증가)
    random_state=42
)

# 모델 학습
svm.fit(X_train_h, y_train_h)

# 예측
y_pred_svm = svm.predict(X_test_h)

# 성능 평가
print("SVM Accuracy:", accuracy_score(y_test_h, y_pred_svm))
print("Precision:", precision_score(y_test_h, y_pred_svm))
print("Recall:", recall_score(y_test_h, y_pred_svm))
print("F1 Score:", f1_score(y_test_h, y_pred_svm))
print("ROC AUC Score:", roc_auc_score(y_test_h, y_pred_svm))
print("Confusion Matrix:\n", confusion_matrix(y_test_h, y_pred_svm))


# 📌 5️⃣ Random Forest (랜덤 포레스트)

from sklearn.ensemble import RandomForestClassifier

# RandomForestClassifier 모델 생성
rf = RandomForestClassifier(
    n_estimators=100,  # 트리 개수 (기본값 100)
    max_depth=None,  # 트리의 최대 깊이 (기본값 None, 자동 설정)
    min_samples_split=2,  # 노드를 분할하기 위한 최소 샘플 수
    min_samples_leaf=1,  # 리프 노드가 가져야 할 최소 샘플 수
    random_state=42
)

# 모델 학습
rf.fit(X_train_h, y_train_h)

# 예측
y_pred_rf = rf.predict(X_test_h)

# 성능 평가
print("Random Forest Accuracy:", accuracy_score(y_test_h, y_pred_rf))
print("Precision:", precision_score(y_test_h, y_pred_rf))
print("Recall:", recall_score(y_test_h, y_pred_rf))
print("F1 Score:", f1_score(y_test_h, y_pred_rf))
print("ROC AUC Score:", roc_auc_score(y_test_h, y_pred_rf))
print("Confusion Matrix:\n", confusion_matrix(y_test_h, y_pred_rf))


# 📌 6️⃣ XGBoost (eXtreme Gradient Boosting)

from xgboost import XGBClassifier

# XGBClassifier 모델 생성
xgb = XGBClassifier(
    n_estimators=50,  # 트리 개수 (기본값 100)
    learning_rate=0.1,  # 학습률 (기본값 0.3)
    max_depth=3,  # 트리의 최대 깊이 (기본값 6)
    use_label_encoder=False,  # 경고 방지 옵션
    eval_metric="logloss",  # 평가 지표
    random_state=42
)

# 모델 학습
xgb.fit(X_train_h, y_train_h)

# 예측
y_pred_xgb = xgb.predict(X_test_h)

# 성능 평가
print("XGBoost Accuracy:", accuracy_score(y_test_h, y_pred_xgb))
print("Precision:", precision_score(y_test_h, y_pred_xgb))
print("Recall:", recall_score(y_test_h, y_pred_xgb))
print("F1 Score:", f1_score(y_test_h, y_pred_xgb))
print("ROC AUC Score:", roc_auc_score(y_test_h, y_pred_xgb))
print("Confusion Matrix:\n", confusion_matrix(y_test_h, y_pred_xgb))


# 📌 7️⃣ AdaBoost (Adaptive Boosting)

from sklearn.ensemble import AdaBoostClassifier

# AdaBoostClassifier 모델 생성
ada = AdaBoostClassifier(
    base_estimator=DecisionTreeClassifier(max_depth=2),  # 기본 학습기는 의사결정나무
    n_estimators=50,  # 약한 학습기의 개수
    learning_rate=0.1,  # 학습률 (기본값 1.0, 작을수록 학습 속도 감소)
    random_state=42
)

# 모델 학습
ada.fit(X_train_h, y_train_h)

# 예측
y_pred_ada = ada.predict(X_test_h)

# 성능 평가
print("AdaBoost Accuracy:", accuracy_score(y_test_h, y_pred_ada))
print("Precision:", precision_score(y_test_h, y_pred_ada))
print("Recall:", recall_score(y_test_h, y_pred_ada))
print("F1 Score:", f1_score(y_test_h, y_pred_ada))
print("ROC AUC Score:", roc_auc_score(y_test_h, y_pred_ada))
print("Confusion Matrix:\n", confusion_matrix(y_test_h, y_pred_ada))


# 📌 8️⃣ Gradient Boosting Machine (GBM)

from sklearn.ensemble import GradientBoostingClassifier

# GradientBoostingClassifier 모델 생성
gbm = GradientBoostingClassifier(
    n_estimators=50,  # 트리 개수
    learning_rate=0.1,  # 학습률 (기본값 0.1)
    max_depth=3,  # 트리 깊이
    subsample=1.0,  # 각 단계에서 사용할 데이터 비율 (기본값 1.0)
    random_state=42
)

# 모델 학습
gbm.fit(X_train_h, y_train_h)

# 예측
y_pred_gbm = gbm.predict(X_test_h)

# 성능 평가
print("Gradient Boosting Machine Accuracy:", accuracy_score(y_test_h, y_pred_gbm))
print("Precision:", precision_score(y_test_h, y_pred_gbm))
print("Recall:", recall_score(y_test_h, y_pred_gbm))
print("F1 Score:", f1_score(y_test_h, y_pred_gbm))
print("ROC AUC Score:", roc_auc_score(y_test_h, y_pred_gbm))
print("Confusion Matrix:\n", confusion_matrix(y_test_h, y_pred_gbm))


# 📌 9️⃣ LightGBM (Light Gradient Boosting Machine)

from lightgbm import LGBMClassifier

# LGBMClassifier 모델 생성
lgbm = LGBMClassifier(
    n_estimators=50,  # 트리 개수 (기본값 100)
    learning_rate=0.1,  # 학습률 (기본값 0.1)
    max_depth=-1,  # 트리 깊이 자동 설정
    num_leaves=31,  # 트리의 리프 개수 (기본값 31, 클수록 복잡한 모델)
    boosting_type='gbdt',  # 부스팅 방식 ('dart', 'rf'도 가능)
    random_state=42
)

# 모델 학습
lgbm.fit(X_train_h, y_train_h)

# 예측
y_pred_lgbm = lgbm.predict(X_test_h)

# 성능 평가
print("LightGBM Accuracy:", accuracy_score(y_test_h, y_pred_lgbm))
print("Precision:", precision_score(y_test_h, y_pred_lgbm))
print("Recall:", recall_score(y_test_h, y_pred_lgbm))
print("F1 Score:", f1_score(y_test_h, y_pred_lgbm))
print("ROC AUC Score:", roc_auc_score(y_test_h, y_pred_lgbm))
print("Confusion Matrix:\n", confusion_matrix(y_test_h, y_pred_lgbm))

 

모델특징

로지스틱 회귀 기본적인 선형 분류 모델, 해석 용이
의사결정 나무 트리를 이용한 쉬운 분류 모델, 과적합 위험 있음
SVM 초평면을 기반으로 데이터 분류, 고차원 데이터에서 유용
랜덤 포레스트 여러 개의 트리를 결합하여 예측, 안정적 성능
XGBoost GBM보다 성능 최적화된 부스팅 모델
AdaBoost 약한 학습기(트리)를 결합하여 강력한 모델 생성
Gradient Boosting 트리를 연속적으로 학습하여 최적의 결과 도출
LightGBM 대용량 데이터에서 빠른 속도로 최적화 가능

 

머신러닝 지도학습 분류모델 (모델별 학습 및 평가) - k-fold 분할

# 📌 Heart 데이터 - K-Fold 교차 검증을 활용한 분류 모델 성능 평가 (다양한 지표 포함)

import pandas as pd
from sklearn.model_selection import KFold, cross_validate
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.svm import SVC
from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier, AdaBoostClassifier
from xgboost import XGBClassifier
from lightgbm import LGBMClassifier
from sklearn.metrics import make_scorer, accuracy_score, precision_score, recall_score, f1_score, roc_auc_score

# 1️⃣ 데이터 불러오기 및 전처리
heart_data = pd.read_csv("datasets/heart.csv")

# X (특성)과 y (타겟) 분리
X_heart = heart_data.drop(columns=["output"])
y_heart = heart_data["output"]

# 데이터 정규화
scaler = StandardScaler()
X_heart_scaled = scaler.fit_transform(X_heart)

# 2️⃣ K-Fold 설정 (5-Fold)
kf = KFold(n_splits=5, shuffle=True, random_state=42)

# 3️⃣ 평가 지표 설정 (정확도, 정밀도, 재현율, F1 점수, ROC AUC)
scoring = {
    "Accuracy": make_scorer(accuracy_score),
    "Precision": make_scorer(precision_score),
    "Recall": make_scorer(recall_score),
    "F1": make_scorer(f1_score),
    "ROC AUC": make_scorer(roc_auc_score)
}

# 4️⃣ Logistic Regression K-Fold 검증
log_reg = LogisticRegression(max_iter=1000, random_state=42)
log_reg_scores = cross_validate(log_reg, X_heart_scaled, y_heart, cv=kf, scoring=scoring)

print("Logistic Regression:")
print("Mean Accuracy:", log_reg_scores['test_Accuracy'].mean())
print("Mean Precision:", log_reg_scores['test_Precision'].mean())
print("Mean Recall:", log_reg_scores['test_Recall'].mean())
print("Mean F1 Score:", log_reg_scores['test_F1'].mean())
print("Mean ROC AUC:", log_reg_scores['test_ROC AUC'].mean())
print("\n")

# 5️⃣ Decision Tree K-Fold 검증
dt = DecisionTreeClassifier(max_depth=5, random_state=42)
dt_scores = cross_validate(dt, X_heart_scaled, y_heart, cv=kf, scoring=scoring)

print("Decision Tree:")
print("Mean Accuracy:", dt_scores['test_Accuracy'].mean())
print("Mean Precision:", dt_scores['test_Precision'].mean())
print("Mean Recall:", dt_scores['test_Recall'].mean())
print("Mean F1 Score:", dt_scores['test_F1'].mean())
print("Mean ROC AUC:", dt_scores['test_ROC AUC'].mean())
print("\n")

# 6️⃣ SVM K-Fold 검증
svm = SVC(kernel="linear", probability=True, random_state=42)
svm_scores = cross_validate(svm, X_heart_scaled, y_heart, cv=kf, scoring=scoring)

print("SVM:")
print("Mean Accuracy:", svm_scores['test_Accuracy'].mean())
print("Mean Precision:", svm_scores['test_Precision'].mean())
print("Mean Recall:", svm_scores['test_Recall'].mean())
print("Mean F1 Score:", svm_scores['test_F1'].mean())
print("Mean ROC AUC:", svm_scores['test_ROC AUC'].mean())
print("\n")

# 7️⃣ Random Forest K-Fold 검증
rf = RandomForestClassifier(n_estimators=100, random_state=42)
rf_scores = cross_validate(rf, X_heart_scaled, y_heart, cv=kf, scoring=scoring)

print("Random Forest:")
print("Mean Accuracy:", rf_scores['test_Accuracy'].mean())
print("Mean Precision:", rf_scores['test_Precision'].mean())
print("Mean Recall:", rf_scores['test_Recall'].mean())
print("Mean F1 Score:", rf_scores['test_F1'].mean())
print("Mean ROC AUC:", rf_scores['test_ROC AUC'].mean())
print("\n")

# 8️⃣ AdaBoost K-Fold 검증
ada = AdaBoostClassifier(base_estimator=DecisionTreeClassifier(max_depth=2), n_estimators=50, random_state=42)
ada_scores = cross_validate(ada, X_heart_scaled, y_heart, cv=kf, scoring=scoring)

print("AdaBoost:")
print("Mean Accuracy:", ada_scores['test_Accuracy'].mean())
print("Mean Precision:", ada_scores['test_Precision'].mean())
print("Mean Recall:", ada_scores['test_Recall'].mean())
print("Mean F1 Score:", ada_scores['test_F1'].mean())
print("Mean ROC AUC:", ada_scores['test_ROC AUC'].mean())
print("\n")

# 9️⃣ Gradient Boosting Machine (GBM) K-Fold 검증
gbm = GradientBoostingClassifier(n_estimators=50, learning_rate=0.1, max_depth=3, random_state=42)
gbm_scores = cross_validate(gbm, X_heart_scaled, y_heart, cv=kf, scoring=scoring)

print("Gradient Boosting:")
print("Mean Accuracy:", gbm_scores['test_Accuracy'].mean())
print("Mean Precision:", gbm_scores['test_Precision'].mean())
print("Mean Recall:", gbm_scores['test_Recall'].mean())
print("Mean F1 Score:", gbm_scores['test_F1'].mean())
print("Mean ROC AUC:", gbm_scores['test_ROC AUC'].mean())
print("\n")

# 🔟 XGBoost K-Fold 검증
xgb = XGBClassifier(n_estimators=50, learning_rate=0.1, max_depth=3, random_state=42, 
                    use_label_encoder=False, eval_metric="logloss")
xgb_scores = cross_validate(xgb, X_heart_scaled, y_heart, cv=kf, scoring=scoring)

print("XGBoost:")
print("Mean Accuracy:", xgb_scores['test_Accuracy'].mean())
print("Mean Precision:", xgb_scores['test_Precision'].mean())
print("Mean Recall:", xgb_scores['test_Recall'].mean())
print("Mean F1 Score:", xgb_scores['test_F1'].mean())
print("Mean ROC AUC:", xgb_scores['test_ROC AUC'].mean())
print("\n")

# 🔟 LightGBM K-Fold 검증
lgbm = LGBMClassifier(n_estimators=50, learning_rate=0.1, max_depth=-1, random_state=42)
lgbm_scores = cross_validate(lgbm, X_heart_scaled, y_heart, cv=kf, scoring=scoring)

print("LightGBM:")
print("Mean Accuracy:", lgbm_scores['test_Accuracy'].mean())
print("Mean Precision:", lgbm_scores['test_Precision'].mean())
print("Mean Recall:", lgbm_scores['test_Recall'].mean())
print("Mean F1 Score:", lgbm_scores['test_F1'].mean())
print("Mean ROC AUC:", lgbm_scores['test_ROC AUC'].mean())
print("\n")

 

K-Fold 교차 검증을 활용한 분류 모델 성능 비교

  1. KFold(n_splits=5, shuffle=True, random_state=42)
    • 데이터를 5개의 부분으로 나누어 5번 교차 검증 수행
    • shuffle=True를 설정하면 데이터를 섞은 후 분할
    • random_state=42로 랜덤성을 고정
  2. cross_validate(estimator, X, y, cv=kf, scoring=scoring)
    • estimator: 사용할 모델 (예: LogisticRegression(), RandomForestClassifier())
    • X: 입력 데이터 (특성)
    • y: 정답 데이터 (타겟)
    • cv=kf: K-Fold 설정 적용
    • scoring: 평가 지표 (정확도, 정밀도, 재현율, F1 점수, ROC AUC)