12-1 데이터분할(분할, k-fold)

와인데이터 - 일반분할

# 📌 1. Wine 데이터 - 일반 Train/Test Split & 다양한 모델 학습

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.ensemble import RandomForestClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.svm import SVC
from xgboost import XGBClassifier
from lightgbm import LGBMClassifier
from sklearn.metrics import accuracy_score

# 데이터 불러오기
wine_data = pd.read_csv("datasets/winequality-white.csv", sep=";")

# X (특성)과 y (타겟) 분리
X_wine = wine_data.drop(columns=["quality"])
y_wine = wine_data["quality"]

# 데이터 정규화
scaler = StandardScaler()
X_wine_scaled = scaler.fit_transform(X_wine)

# Train/Test Split
X_train_w, X_test_w, y_train_w, y_test_w = train_test_split(X_wine_scaled, y_wine, test_size=0.2, random_state=42)

# 모델 학습 및 평가

# Logistic Regression
log_reg = LogisticRegression(max_iter=1000, random_state=42)
log_reg.fit(X_train_w, y_train_w)
y_pred_log_reg = log_reg.predict(X_test_w)
print("Wine Data Logistic Regression Accuracy:", accuracy_score(y_test_w, y_pred_log_reg))

# Decision Tree
dt = DecisionTreeClassifier(max_depth=3, random_state=42)
dt.fit(X_train_w, y_train_w)
y_pred_dt = dt.predict(X_test_w)
print("Wine Data Decision Tree Accuracy:", accuracy_score(y_test_w, y_pred_dt))

# SVM
svm = SVC(kernel="linear", probability=True, random_state=42)
svm.fit(X_train_w, y_train_w)
y_pred_svm = svm.predict(X_test_w)
print("Wine Data SVM Accuracy:", accuracy_score(y_test_w, y_pred_svm))

# Random Forest
rf = RandomForestClassifier(n_estimators=100, random_state=42)
rf.fit(X_train_w, y_train_w)
y_pred_rf = rf.predict(X_test_w)
print("Wine Data Random Forest Accuracy:", accuracy_score(y_test_w, y_pred_rf))

# XGBoost
xgb = XGBClassifier(n_estimators=50, learning_rate=0.1, max_depth=3, random_state=42, use_label_encoder=False, eval_metric="logloss")
xgb.fit(X_train_w, y_train_w)
y_pred_xgb = xgb.predict(X_test_w)
print("Wine Data XGBoost Accuracy:", accuracy_score(y_test_w, y_pred_xgb))

# LightGBM
lgbm = LGBMClassifier(n_estimators=50, learning_rate=0.1, max_depth=-1, random_state=42)
lgbm.fit(X_train_w, y_train_w)
y_pred_lgbm = lgbm.predict(X_test_w)
print("Wine Data LightGBM Accuracy:", accuracy_score(y_test_w, y_pred_lgbm))

 

와인데이터 - k-fold분할

# 📌 Wine 데이터 - K-Fold 교차 검증 후 모델 학습 및 평가 (옵션 설명 포함)

import pandas as pd
from sklearn.model_selection import KFold, cross_val_score
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
from xgboost import XGBClassifier
from lightgbm import LGBMClassifier

# 1️⃣ 데이터 불러오기
wine_data = pd.read_csv("datasets/winequality-white.csv", sep=";")

# 2️⃣ X (특성)과 y (타겟) 분리
X_wine = wine_data.drop(columns=["quality"])
y_wine = wine_data["quality"]

# 3️⃣ 데이터 정규화
scaler = StandardScaler()
X_wine_scaled = scaler.fit_transform(X_wine)

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

# 5️⃣ Logistic Regression 모델 교차 검증
log_reg = LogisticRegression(max_iter=1000, random_state=42)
log_reg_kf = cross_val_score(
    estimator=log_reg,  # 사용할 모델
    X=X_wine_scaled,  # 입력 데이터 (특성)
    y=y_wine,  # 타겟 데이터 (정답)
    cv=kf,  # 교차 검증 방법 (5-Fold)
    scoring="accuracy"  # 평가 지표 (정확도)
)
print("Wine Data Logistic Regression K-Fold Accuracy Scores:", log_reg_kf)
print("Wine Data Logistic Regression K-Fold Mean Accuracy:", log_reg_kf.mean())

# 6️⃣ Decision Tree 모델 교차 검증
dt = DecisionTreeClassifier(max_depth=3, random_state=42)
dt_kf = cross_val_score(dt, X_wine_scaled, y_wine, cv=kf, scoring="accuracy")
print("Wine Data Decision Tree K-Fold Accuracy Scores:", dt_kf)
print("Wine Data Decision Tree K-Fold Mean Accuracy:", dt_kf.mean())

# 7️⃣ SVM 모델 교차 검증
svm = SVC(kernel="linear", probability=True, random_state=42)
svm_kf = cross_val_score(
    svm, X_wine_scaled, y_wine, 
    cv=kf, 
    scoring="accuracy"
)
print("Wine Data SVM K-Fold Accuracy Scores:", svm_kf)
print("Wine Data SVM K-Fold Mean Accuracy:", svm_kf.mean())

# 8️⃣ Random Forest 모델 교차 검증
rf = RandomForestClassifier(n_estimators=100, random_state=42)
rf_kf = cross_val_score(rf, X_wine_scaled, y_wine, cv=kf, scoring="accuracy")
print("Wine Data Random Forest K-Fold Accuracy Scores:", rf_kf)
print("Wine Data Random Forest K-Fold Mean Accuracy:", rf_kf.mean())

# 9️⃣ XGBoost 모델 교차 검증
xgb = XGBClassifier(n_estimators=50, learning_rate=0.1, max_depth=3, random_state=42, 
                    use_label_encoder=False, eval_metric="logloss")
xgb_kf = cross_val_score(
    xgb, X_wine_scaled, y_wine, 
    cv=kf, 
    scoring="accuracy"
)
print("Wine Data XGBoost K-Fold Accuracy Scores:", xgb_kf)
print("Wine Data XGBoost K-Fold Mean Accuracy:", xgb_kf.mean())

# 🔟 LightGBM 모델 교차 검증
lgbm = LGBMClassifier(n_estimators=50, learning_rate=0.1, max_depth=-1, random_state=42)
lgbm_kf = cross_val_score(
    lgbm, X_wine_scaled, y_wine, 
    cv=kf, 
    scoring="accuracy"
)
print("Wine Data LightGBM K-Fold Accuracy Scores:", lgbm_kf)
print("Wine Data LightGBM K-Fold Mean Accuracy:", lgbm_kf.mean())

"""
✅ cross_val_score 옵션 설명 ✅
- estimator: 사용할 모델 (예: LogisticRegression(), RandomForestClassifier() 등)
- X: 입력 데이터 (특성 행렬)
- y: 정답 데이터 (타겟 벡터)
- cv: 교차 검증 방법 (ex: KFold(n_splits=5))
- scoring: 평가 지표 (예: "accuracy"=정확도, "f1"=F1 점수, "roc_auc"=AUC 점수 등)
- n_jobs: 병렬 처리 개수 (-1은 모든 코어 사용, 기본값은 1)
- verbose: 실행 과정 출력 여부 (기본값 0, 높일수록 상세 출력)
"""

 

심장병데이터 - 일반분할

# 📌 Heart 데이터 - 일반 Train/Test Split 후 다양한 모델 학습 및 평가

import pandas as pd
from sklearn.model_selection import train_test_split
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
from xgboost import XGBClassifier
from lightgbm import LGBMClassifier
from sklearn.metrics import accuracy_score

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

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

# 3️⃣ 데이터 정규화 (모델 성능 향상을 위해)
scaler = StandardScaler()
X_heart_scaled = scaler.fit_transform(X_heart)

# 4️⃣ Train/Test Split (80:20 비율로 데이터 분할)
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)

# 5️⃣ Logistic Regression 모델 학습 및 평가
log_reg = LogisticRegression(max_iter=1000, random_state=42)
log_reg.fit(X_train_h, y_train_h)
y_pred_log_reg = log_reg.predict(X_test_h)
print("Heart Data Logistic Regression Accuracy:", accuracy_score(y_test_h, y_pred_log_reg))

# 6️⃣ Decision Tree 모델 학습 및 평가
dt = DecisionTreeClassifier(max_depth=3, random_state=42)
dt.fit(X_train_h, y_train_h)
y_pred_dt = dt.predict(X_test_h)
print("Heart Data Decision Tree Accuracy:", accuracy_score(y_test_h, y_pred_dt))

# 7️⃣ SVM 모델 학습 및 평가
svm = SVC(kernel="linear", probability=True, random_state=42)
svm.fit(X_train_h, y_train_h)
y_pred_svm = svm.predict(X_test_h)
print("Heart Data SVM Accuracy:", accuracy_score(y_test_h, y_pred_svm))

# 8️⃣ Random Forest 모델 학습 및 평가
rf = RandomForestClassifier(n_estimators=100, random_state=42)
rf.fit(X_train_h, y_train_h)
y_pred_rf = rf.predict(X_test_h)
print("Heart Data Random Forest Accuracy:", accuracy_score(y_test_h, y_pred_rf))

# 9️⃣ XGBoost 모델 학습 및 평가
xgb = XGBClassifier(n_estimators=50, learning_rate=0.1, max_depth=3, random_state=42, 
                    use_label_encoder=False, eval_metric="logloss")
xgb.fit(X_train_h, y_train_h)
y_pred_xgb = xgb.predict(X_test_h)
print("Heart Data XGBoost Accuracy:", accuracy_score(y_test_h, y_pred_xgb))

# 🔟 LightGBM 모델 학습 및 평가
lgbm = LGBMClassifier(n_estimators=50, learning_rate=0.1, max_depth=-1, random_state=42)
lgbm.fit(X_train_h, y_train_h)
y_pred_lgbm = lgbm.predict(X_test_h)
print("Heart Data LightGBM Accuracy:", accuracy_score(y_test_h, y_pred_lgbm))

 

심장병데이터 - k-fold분할

# 📌 Heart 데이터 - K-Fold 교차 검증 후 다양한 모델 학습 및 평가

import pandas as pd
from sklearn.model_selection import KFold, cross_val_score
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
from xgboost import XGBClassifier
from lightgbm import LGBMClassifier

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

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

# 3️⃣ 데이터 정규화 (모델 성능 향상을 위해)
scaler = StandardScaler()
X_heart_scaled = scaler.fit_transform(X_heart)

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

# 5️⃣ Logistic Regression 모델 교차 검증
log_reg = LogisticRegression(max_iter=1000, random_state=42)
log_reg_kf = cross_val_score(log_reg, X_heart_scaled, y_heart, cv=kf, scoring="accuracy")
print("Heart Data Logistic Regression K-Fold Accuracy Scores:", log_reg_kf)
print("Heart Data Logistic Regression K-Fold Mean Accuracy:", log_reg_kf.mean())

# 6️⃣ Decision Tree 모델 교차 검증
dt = DecisionTreeClassifier(max_depth=3, random_state=42)
dt_kf = cross_val_score(dt, X_heart_scaled, y_heart, cv=kf, scoring="accuracy")
print("Heart Data Decision Tree K-Fold Accuracy Scores:", dt_kf)
print("Heart Data Decision Tree K-Fold Mean Accuracy:", dt_kf.mean())

# 7️⃣ SVM 모델 교차 검증
svm = SVC(kernel="linear", probability=True, random_state=42)
svm_kf = cross_val_score(svm, X_heart_scaled, y_heart, cv=kf, scoring="accuracy")
print("Heart Data SVM K-Fold Accuracy Scores:", svm_kf)
print("Heart Data SVM K-Fold Mean Accuracy:", svm_kf.mean())

# 8️⃣ Random Forest 모델 교차 검증
rf = RandomForestClassifier(n_estimators=100, random_state=42)
rf_kf = cross_val_score(rf, X_heart_scaled, y_heart, cv=kf, scoring="accuracy")
print("Heart Data Random Forest K-Fold Accuracy Scores:", rf_kf)
print("Heart Data Random Forest K-Fold Mean Accuracy:", rf_kf.mean())

# 9️⃣ XGBoost 모델 교차 검증
xgb = XGBClassifier(n_estimators=50, learning_rate=0.1, max_depth=3, random_state=42, 
                    use_label_encoder=False, eval_metric="logloss")
xgb_kf = cross_val_score(xgb, X_heart_scaled, y_heart, cv=kf, scoring="accuracy")
print("Heart Data XGBoost K-Fold Accuracy Scores:", xgb_kf)
print("Heart Data XGBoost K-Fold Mean Accuracy:", xgb_kf.mean())

# 🔟 LightGBM 모델 교차 검증
lgbm = LGBMClassifier(n_estimators=50, learning_rate=0.1, max_depth=-1, random_state=42)
lgbm_kf = cross_val_score(lgbm, X_heart_scaled, y_heart, cv=kf, scoring="accuracy")
print("Heart Data LightGBM K-Fold Accuracy Scores:", lgbm_kf)
print("Heart Data LightGBM K-Fold Mean Accuracy:", lgbm_kf.mean())

 

주요 옵션 설명

1️⃣ pd.read_csv(filepath, sep=";", encoding="utf-8")

• filepath: 불러올 CSV 파일 경로 지정
• sep=";": 데이터의 구분자 지정 (기본값은 , 이지만, 데이터에 따라 ;나 \t를 사용할 수도 있음)
• encoding="utf-8": 파일의 인코딩을 지정 (한글 데이터의 경우 encoding="cp949"를 사용할 수도 있음)

---

2️⃣ train_test_split(X, y, test_size=0.2, random_state=42)

• X: 입력 데이터 (특성)
• y: 타겟 데이터 (정답 레이블)
• test_size=0.2: 80%는 훈련 데이터, 20%는 테스트 데이터로 분리
• random_state=42: 실행할 때마다 같은 결과를 보장 (랜덤성을 고정)

---

3️⃣ StandardScaler().fit_transform(X)

• 데이터를 표준화(정규화)하여 평균이 0, 표준편차가 1이 되도록 변환
• fit_transform(X): X 데이터를 기준으로 스케일링 적용 후 변환

---

4️⃣ LogisticRegression(max_iter=1000, random_state=42)

• max_iter=1000: 최적의 모델을 찾기 위해 최대 1000번 반복
• random_state=42: 실행할 때마다 같은 결과를 보장

---

5️⃣ DecisionTreeClassifier(max_depth=3, random_state=42)

• max_depth=3: 트리의 최대 깊이를 3으로 제한 (너무 깊어지면 과적합 위험 증가)
• random_state=42: 실행할 때마다 같은 결과를 보장

---

6️⃣ SVC(kernel="linear", probability=True, random_state=42)

• kernel="linear": 선형 SVM 사용 (비선형일 경우 "rbf", "poly" 선택 가능)
• probability=True: 예측 시 확률 값 제공 (속도는 느려지지만 확률 예측이 필요할 경우 사용)
• random_state=42: 실행할 때마다 같은 결과를 보장

---

7️⃣ RandomForestClassifier(n_estimators=100, random_state=42)

• n_estimators=100: 100개의 결정 트리를 생성하여 예측
• random_state=42: 실행할 때마다 같은 결과를 보장

---

8️⃣ XGBClassifier(n_estimators=50, learning_rate=0.1, max_depth=3, random_state=42, use_label_encoder=False, eval_metric="logloss")

• n_estimators=50: 50개의 트리를 사용하여 학습
• learning_rate=0.1: 학습 속도를 조절 (값이 너무 크면 과적합, 너무 작으면 학습 속도가 느림)
• max_depth=3: 트리의 최대 깊이
• random_state=42: 실행할 때마다 같은 결과를 보장
• use_label_encoder=False: 경고 메시지 방지 (XGBoost 1.3 이후 필요)
• eval_metric="logloss": 손실 함수(예측의 정확도 평가 방법) 설정

---

9️⃣ LGBMClassifier(n_estimators=50, learning_rate=0.1, max_depth=-1, random_state=42)

• n_estimators=50: 50개의 트리를 사용하여 학습
• learning_rate=0.1: 학습 속도 조절
• max_depth=-1: 트리의 깊이를 자동으로 설정
• random_state=42: 실행할 때마다 같은 결과를 보장

---

🔟 KFold(n_splits=5, shuffle=True, random_state=42)

• n_splits=5: 데이터를 5개로 나누어 교차 검증 수행
• shuffle=True: 데이터를 섞은 후 분할 (데이터 순서에 따른 편향 방지)
• random_state=42: 실행할 때마다 같은 결과를 보장

---

1️⃣1️⃣ cross_val_score(estimator, X, y, cv=5, scoring="accuracy")

• estimator: 사용할 모델 (예: LogisticRegression(), RandomForestClassifier())
• X: 입력 데이터 (특성)
• y: 정답 데이터 (타겟)
• cv=5: 5-Fold 교차 검증 적용
• scoring="accuracy": 정확도를 평가 지표로 사용 ("f1", "roc_auc"도 가능)

---

1️⃣2️⃣ model.fit(X_train, y_train)

• X_train: 훈련 데이터
• y_train: 정답 데이터
• 주어진 모델을 학습시키는 함수

---

1️⃣3️⃣ model.predict(X_test)

• X_test: 테스트 데이터
• 학습된 모델을 사용해 예측값을 반환

---

1️⃣4️⃣ accuracy_score(y_test, y_pred)

• y_test: 실제 정답값
• y_pred: 모델이 예측한 값
• 정확도를 계산하여 출력 (1에 가까울수록 정확함)

---

🌟 정리

1. 데이터 불러오기 및 전처리

• pd.read_csv(): CSV 파일 불러오기
• train_test_split(): 데이터 분할
• StandardScaler().fit_transform(): 데이터 정규화

2. 모델 학습 및 평가

• LogisticRegression(), DecisionTreeClassifier(), SVC(), RandomForestClassifier(), XGBClassifier(), LGBMClassifier()
• model.fit(): 모델 학습
• model.predict(): 모델 예측
• accuracy_score(): 모델 정확도 평가

3. K-Fold 교차 검증

• KFold(): K-Fold 설정
• cross_val_score(): 교차 검증 수행

이제 위 함수들을 이해하고 직접 사용하면서 머신러닝 모델을 쉽게 다룰 수 있습니다! 🚀