머신러닝 지도학습 분류모델 (데이터 불러오기, 전처리) - 일반분할
이패스 신성진 김용재 와 함께하는 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 교차 검증을 활용한 분류 모델 성능 비교
- KFold(n_splits=5, shuffle=True, random_state=42)
- 데이터를 5개의 부분으로 나누어 5번 교차 검증 수행
- shuffle=True를 설정하면 데이터를 섞은 후 분할
- random_state=42로 랜덤성을 고정
- cross_validate(estimator, X, y, cv=kf, scoring=scoring)
- estimator: 사용할 모델 (예: LogisticRegression(), RandomForestClassifier())
- X: 입력 데이터 (특성)
- y: 정답 데이터 (타겟)
- cv=kf: K-Fold 설정 적용
- scoring: 평가 지표 (정확도, 정밀도, 재현율, F1 점수, ROC AUC)
'파이썬' 카테고리의 다른 글
이패스 신성진 김용재 와 함께하는 AI모델링 (0) | 2025.03.18 |
---|---|
12-4. 머신러닝 회귀모델 총정리 (이패스 신성진 김용재 와 함께하는 AI모델링) (0) | 2025.03.18 |
13. 모델평가 (모델성능비교) (0) | 2025.03.18 |
12-1 데이터분할(분할, k-fold) (0) | 2025.03.18 |
12-2. 머신러닝 지도학습 (0) | 2025.03.18 |