사이킷런(sklearn)라이브러리
pip install scikit-learn --upgrade --user
서브 라이브러리(Sub library)
# 선형 회귀 모델을 제공하는 서브라이브러리
from sklearn.linear_model import LinearRegression
# 데이터 분리 기능을 제공하는 서브라이브러리
from sklearn.model_selection import train_test_split
모듈(Module)
# train_test_split은 sklearn.model_selection 서브라이브러리 안에 있는 모듈
from sklearn.model_selection import train_test_split
# LinearRegression은 sklearn.linear_model 서브라이브러리 안에 있는 모듈
from sklearn.linear_model import LinearRegression
차이점 요약
# 서브라이브러리를 살펴보기
import sklearn.model_selection # 데이터 분리 관련
help(sklearn.model_selection) # 내부에 포함된 모듈 확인
# 모듈의 세부 기능 살펴보기
from sklearn.model_selection import train_test_split
help(train_test_split) # 데이터 분리 함수의 상세 정보 확인
서브라이브러리와 모듈 사용 예제
# 데이터 분리 기능을 사용해보기
# sklearn의 model_selection 서브라이브러리에서 train_test_split 모듈을 가져옵니다.
from sklearn.model_selection import train_test_split
# 선형 회귀 모델을 사용해보기
# sklearn의 linear_model 서브라이브러리에서 LinearRegression 모듈을 가져옵니다.
from sklearn.linear_model import LinearRegression
# 데이터 평가 기능을 사용해보기
# sklearn의 metrics 서브라이브러리에서 mean_squared_error 모듈을 가져옵니다.
from sklearn.metrics import mean_squared_error
# 데이터 생성
# pandas 라이브러리를 사용해 데이터프레임 형태의 데이터를 만듭니다.
import pandas as pd # pandas는 데이터를 다루기 위한 라이브러리입니다.
# 간단한 데이터셋을 만듭니다. Feature는 입력 데이터, Target은 정답 값입니다.
data = {'Feature': [1, 2, 3, 4, 5], 'Target': [3, 6, 9, 12, 15]}
df = pd.DataFrame(data) # 데이터프레임 생성
# 입력 데이터(X)와 출력 데이터(y)로 분리
# Feature 열은 입력으로 사용하고, Target 열은 출력 값으로 사용합니다.
X = df[['Feature']] # 입력 데이터 (2차원 배열로 만들어야 합니다)
y = df['Target'] # 출력 데이터 (1차원 배열로 저장)
# 데이터를 학습용 데이터와 테스트용 데이터로 나눕니다.
# train_test_split 함수는 데이터를 랜덤하게 분리하는 기능을 제공합니다.
X_train, X_test, y_train, y_test = train_test_split(
X, y, # 입력 데이터(X)와 출력 데이터(y)를 넣습니다.
test_size=0.2, # 전체 데이터의 20%를 테스트용 데이터로 사용합니다.
random_state=42 # 결과 재현을 위해 랜덤 시드를 고정합니다.
)
# 선형 회귀 모델 생성 및 학습
# LinearRegression 클래스는 선형 회귀 모델을 제공합니다.
model = LinearRegression() # 모델 객체 생성
model.fit(X_train, y_train) # 모델을 학습용 데이터로 학습시킵니다.
# 학습된 모델로 테스트 데이터를 예측
# 학습된 모델을 사용해 X_test의 출력 값을 예측합니다.
predictions = model.predict(X_test)
# 모델 성능 평가
# mean_squared_error 함수로 실제 값(y_test)과 예측 값(predictions) 간의 차이를 계산합니다.
mse = mean_squared_error(y_test, predictions) # 평균 제곱 오차 계산
print("Mean Squared Error:", mse) # 평가 결과 출력
선형회귀
# 필요한 라이브러리 불러오기
import pandas as pd # 데이터 처리
from sklearn.model_selection import train_test_split # 데이터 분리
from sklearn.linear_model import LinearRegression # 선형 회귀 모델
from sklearn.metrics import mean_squared_error, r2_score # 평가 지표
# 1. 데이터 로드
# 'winequality-white.csv' 파일을 읽어와 데이터프레임 생성
data = pd.read_csv('datasets/winequality-white.csv')
# 2. 입력(X)과 출력(y) 분리
# 독립 변수(X): 'quality'를 제외한 나머지 특성
# 종속 변수(y): 'quality' 열
X = data.drop(['quality','alcohol'], axis=1) # 입력 데이터 (와인의 특성들)
y = data['quality'] # 출력 데이터 (와인의 품질 점수)
# 3. 데이터를 학습용과 테스트용으로 나누기
# 학습 데이터: 80%, 테스트 데이터: 20%
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# 4. 모델 생성 및 학습
model = LinearRegression() # 선형 회귀 모델 생성
model.fit(X_train, y_train) # 학습 데이터로 모델 학습
# 5. 테스트 데이터로 예측 수행
y_pred = model.predict(X_test)
# 6. 모델 평가
mse = mean_squared_error(y_test, y_pred) # 평균 제곱 오차 계산
r2 = r2_score(y_test, y_pred) # 결정 계수 계산
# 결과 출력
print("Mean Squared Error:", mse)
print("R² Score:", r2)
import numpy as np
# 평가 지표 계산
mse = mean_squared_error(y_test, y_pred) # 평균 제곱 오차
rmse = np.sqrt(mse) # 루트 평균 제곱 오차
r2 = r2_score(y_test, y_pred) # 결정 계수
# 평가 결과 출력
print("Mean Squared Error (MSE):", mse)
print("Root Mean Squared Error (RMSE):", rmse)
print("R² Score:", r2)
import matplotlib.pyplot as plt
# 실제 값 vs 예측 값 비교
plt.figure(figsize=(8, 6))
plt.scatter(y_test, y_pred, alpha=0.6, color='blue', label='Predicted vs Actual')
plt.plot([y_test.min(), y_test.max()], [y_test.min(), y_test.max()], 'r--', lw=2, label='Ideal Line')
plt.xlabel("Actual Values")
plt.ylabel("Predicted Values")
plt.title("Actual vs Predicted Values")
plt.legend()
plt.grid()
plt.show()
# 잔차(Residual) 시각화
residuals = y_test - y_pred # 잔차 계산
plt.figure(figsize=(8, 6))
plt.scatter(y_pred, residuals, alpha=0.6, color='purple')
plt.axhline(y=0, color='r', linestyle='--', lw=2)
plt.xlabel("Predicted Values")
plt.ylabel("Residuals")
plt.title("Residual Plot")
plt.grid()
plt.show()
로지스틱 선형회귀 모델
import numpy as np
import matplotlib.pyplot as plt
# 시그모이드 함수 정의
def sigmoid(z):
return 1 / (1 + np.exp(-z))
# 값 생성
z = np.linspace(-10, 10, 100) # -10부터 10까지 100개 점 생성
sigmoid_values = sigmoid(z)
# 그래프 그리기
plt.plot(z, sigmoid_values)
plt.title('Sigmoid Function')
plt.xlabel('z')
plt.ylabel('Sigmoid(z)')
plt.grid()
plt.show()
# 필요한 라이브러리 불러오기
import pandas as pd # 데이터 처리
from sklearn.model_selection import train_test_split # 데이터 분리
from sklearn.linear_model import LogisticRegression # 로지스틱 회귀 모델
from sklearn.metrics import accuracy_score, confusion_matrix # 평가 지표
# 1. 데이터 로드
# 'heart.csv' 파일을 읽어와 데이터프레임 생성
data = pd.read_csv('datasets/heart.csv')
# 2. 입력(X)과 출력(y) 분리
# 'target' 열이 심장병 여부 (1: 있음, 0: 없음)
X = data.drop('output', axis=1) # 독립 변수: 'output'을 제외한 모든 열
y = data['output'] # 종속 변수: 'output'
# 3. 데이터를 학습용과 테스트용으로 나누기
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.2, random_state=42) # 학습 80%, 테스트 20%
# 4. 모델 생성 및 학습
model = LogisticRegression(max_iter=1000) # 로지스틱 회귀 모델 생성 (반복 횟수 1000으로 설정)
model.fit(X_train, y_train) # 학습 데이터로 모델 학습
# 5. 테스트 데이터로 예측 수행
y_pred = model.predict(X_test) # 학습된 모델로 테스트 데이터 예측
# 6. 모델 평가
accuracy = accuracy_score(y_test, y_pred) # 정확도 계산
conf_matrix = confusion_matrix(y_test, y_pred) # 혼동 행렬 계산
# 결과 출력
print("Accuracy:", accuracy) # 정확도 출력
print("Confusion Matrix:\n", conf_matrix) # 혼동 행렬 출력
from sklearn.metrics import classification_report
# 정밀도, 재현율, F1 스코어 출력
print("Classification Report:\n", classification_report(y_test, y_pred))
import seaborn as sns
import matplotlib.pyplot as plt
# 혼동 행렬 시각화
plt.figure(figsize=(6, 4))
sns.heatmap(conf_matrix, annot=True, fmt="d", cmap="Blues", xticklabels=["Class 0", "Class 1"], yticklabels=["Class 0", "Class 1"])
plt.title("Confusion Matrix")
plt.xlabel("Predicted Label")
plt.ylabel("True Label")
plt.show()
k-NN 모델
# k-NN (k-Nearest Neighbors) 알고리즘 예제 (옵션별 다양한 설정)
import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score, classification_report, confusion_matrix
# 1️⃣ 데이터 불러오기
data = pd.read_csv("datasets/heart.csv")
# 2️⃣ 특성(X)과 타겟(y) 분리
X = data.drop(columns=["output"]) # 'output' 열을 제외한 나머지 특성을 X로 설정
y = data["output"] # 'output' 열을 타겟 변수로 설정
# 3️⃣ 데이터 나누기 (훈련 데이터와 테스트 데이터)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# 4️⃣ 데이터 정규화 (StandardScaler 적용)
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train) # 훈련 데이터 기준으로 스케일링 적용
X_test_scaled = scaler.transform(X_test) # 동일한 스케일 적용
# 5️⃣ k-NN 모델 생성 및 훈련 (기본 설정)
knn = KNeighborsClassifier(n_neighbors=5) # k값을 5로 설정
knn.fit(X_train_scaled, y_train) # 모델 학습
# 6️⃣ 예측 수행
y_pred = knn.predict(X_test_scaled)
# 7️⃣ 성능 평가
print("Accuracy:", accuracy_score(y_test, y_pred))
print("Confusion Matrix:\n", confusion_matrix(y_test, y_pred))
print("Classification Report:\n", classification_report(y_test, y_pred))
# 8️⃣ 다양한 k-NN 설정 예제
## ✅ k값 조정 (이웃 수 변경)
knn_k3 = KNeighborsClassifier(n_neighbors=3) # k=3 설정
knn_k3.fit(X_train_scaled, y_train)
print("Accuracy with k=3:", knn_k3.score(X_test_scaled, y_test))
knn_k10 = KNeighborsClassifier(n_neighbors=10) # k=10 설정
knn_k10.fit(X_train_scaled, y_train)
print("Accuracy with k=10:", knn_k10.score(X_test_scaled, y_test))
## ✅ 거리 측정 방법 변경
knn_manhattan = KNeighborsClassifier(n_neighbors=5, metric="manhattan") # 맨해튼 거리 사용
knn_manhattan.fit(X_train_scaled, y_train)
print("Accuracy with Manhattan distance:", knn_manhattan.score(X_test_scaled, y_test))
knn_euclidean = KNeighborsClassifier(n_neighbors=5, metric="euclidean") # 유클리드 거리 사용
knn_euclidean.fit(X_train_scaled, y_train)
print("Accuracy with Euclidean distance:", knn_euclidean.score(X_test_scaled, y_test))
## ✅ 가중치 적용 (distance 기반 가중치)
knn_weighted = KNeighborsClassifier(n_neighbors=5, weights="distance") # 가까운 이웃에 더 높은 가중치 부여
knn_weighted.fit(X_train_scaled, y_train)
print("Accuracy with distance-weighted k-NN:", knn_weighted.score(X_test_scaled, y_test))
## ✅ 분류기 투표 방식 변경 (uniform vs. distance)
knn_uniform = KNeighborsClassifier(n_neighbors=5, weights="uniform") # 모든 이웃이 동일한 가중치
knn_uniform.fit(X_train_scaled, y_train)
print("Accuracy with uniform weights:", knn_uniform.score(X_test_scaled, y_test))
# 🎯 최종 정리
# k-NN의 다양한 옵션을 조합하여 모델 성능을 비교
# - k 값 변경 (n_neighbors)
# - 거리 측정 방법 변경 (metric)
# - 가중치 적용 방식 (weights)
SVM 모델
# Support Vector Machine (SVM) 예제 (옵션별 다양한 설정)
import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVC
from sklearn.metrics import accuracy_score, classification_report, confusion_matrix
# 1️⃣ 데이터 불러오기
data = pd.read_csv("datasets/heart.csv")
# 2️⃣ 특성(X)과 타겟(y) 분리
X = data.drop(columns=["output"]) # 'output' 열을 제외한 나머지를 X로 설정
y = data["output"] # 'output' 열을 타겟 변수로 설정
# 3️⃣ 데이터 나누기 (훈련 데이터와 테스트 데이터)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# 4️⃣ 데이터 정규화 (StandardScaler 적용)
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train) # 훈련 데이터 기준으로 스케일링 적용
X_test_scaled = scaler.transform(X_test) # 동일한 스케일 적용
# 5️⃣ 기본 SVM 모델 생성 및 훈련 (Linear SVM)
svm_model = SVC(kernel="linear", random_state=42) # 선형 커널 사용
svm_model.fit(X_train_scaled, y_train) # 모델 학습
# 6️⃣ 예측 수행
y_pred = svm_model.predict(X_test_scaled)
# 7️⃣ 성능 평가
print("Accuracy:", accuracy_score(y_test, y_pred))
print("Confusion Matrix:\n", confusion_matrix(y_test, y_pred))
print("Classification Report:\n", classification_report(y_test, y_pred))
# 8️⃣ 다양한 SVM 설정 예제
## ✅ 커널 변경 (선형, 다항식, RBF, 시그모이드)
svm_linear = SVC(kernel="linear") # 선형 커널
svm_linear.fit(X_train_scaled, y_train)
print("Accuracy with Linear Kernel:", svm_linear.score(X_test_scaled, y_test))
svm_poly = SVC(kernel="poly", degree=3) # 다항식 커널 (3차)
svm_poly.fit(X_train_scaled, y_train)
print("Accuracy with Polynomial Kernel (degree=3):", svm_poly.score(X_test_scaled, y_test))
svm_rbf = SVC(kernel="rbf") # RBF (Radial Basis Function) 커널
svm_rbf.fit(X_train_scaled, y_train)
print("Accuracy with RBF Kernel:", svm_rbf.score(X_test_scaled, y_test))
svm_sigmoid = SVC(kernel="sigmoid") # Sigmoid 커널
svm_sigmoid.fit(X_train_scaled, y_train)
print("Accuracy with Sigmoid Kernel:", svm_sigmoid.score(X_test_scaled, y_test))
## ✅ 하이퍼파라미터 C 변경 (정규화 강도 조절)
svm_c1 = SVC(kernel="linear", C=0.1) # C가 작을수록 규제가 강함
svm_c1.fit(X_train_scaled, y_train)
print("Accuracy with C=0.1:", svm_c1.score(X_test_scaled, y_test))
svm_c10 = SVC(kernel="linear", C=10) # C가 클수록 규제가 약함
svm_c10.fit(X_train_scaled, y_train)
print("Accuracy with C=10:", svm_c10.score(X_test_scaled, y_test))
## ✅ 감마 값 변경 (RBF, 다항식, 시그모이드 커널에서 사용)
svm_gamma_low = SVC(kernel="rbf", gamma=0.01) # 작은 감마 값
svm_gamma_low.fit(X_train_scaled, y_train)
print("Accuracy with gamma=0.01:", svm_gamma_low.score(X_test_scaled, y_test))
svm_gamma_high = SVC(kernel="rbf", gamma=1) # 큰 감마 값
svm_gamma_high.fit(X_train_scaled, y_train)
print("Accuracy with gamma=1:", svm_gamma_high.score(X_test_scaled, y_test))
## ✅ 확률 추정 사용 (probability=True)
svm_prob = SVC(kernel="rbf", probability=True) # 확률 예측 활성화
svm_prob.fit(X_train_scaled, y_train)
y_prob = svm_prob.predict_proba(X_test_scaled) # 클래스별 확률 예측
print("Predicted Probabilities:\n", y_prob[:5])
# 최종 정리
# - 커널 변경 (linear, poly, rbf, sigmoid)
# - C 값 변경 (정규화 강도 조절)
# - 감마 값 변경 (gamma)
# - 확률 예측 활성화 (probability=True)
의사결정모델
import pandas as pd
df = pd.read_csv("datasets/heart.csv")
df.head()
# 필요한 라이브러리 불러오기
import pandas as pd # 데이터 처리
from sklearn.model_selection import train_test_split # 데이터 분리
from sklearn.tree import DecisionTreeClassifier # 의사결정 나무 모델
from sklearn.metrics import accuracy_score, confusion_matrix, classification_report
# 평가 지표
import matplotlib.pyplot as plt # 시각화
from sklearn.tree import plot_tree # 의사결정 나무 시각화
# 1. 데이터 로드
data = pd.read_csv('datasets/heart.csv')
# 2. 입력(X)과 출력(y) 분리
X = data.drop('output', axis=1) # 'output'을 제외한 모든 열
y = data['output'] # 심장병 여부 (1: 있음, 0: 없음)
# 3. 데이터를 학습용과 테스트용으로 나누기
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# 4. 모델 생성 및 학습
model = DecisionTreeClassifier(max_depth=4, random_state=42) # 트리 깊이 제한
model.fit(X_train, y_train)
# 5. 테스트 데이터로 예측
y_pred = model.predict(X_test)
# 6. 모델 평가
accuracy = accuracy_score(y_test, y_pred) # 정확도 계산
conf_matrix = confusion_matrix(y_test, y_pred) # 혼동 행렬 계산
report = classification_report(y_test, y_pred) # 정밀도, 재현율, F1 스코어 계산
# 평가 결과 출력
print("Accuracy:", accuracy)
print("Confusion Matrix:\n", conf_matrix)
print("Classification Report:\n", report)
# 7. 의사결정 나무 시각화
plt.figure(figsize=(20, 10))
plot_tree(model, feature_names=X.columns, class_names=["No Disease", "Disease"], filled=True, rounded=True)
plt.title("Decision Tree Visualization")
plt.show()
앙상블모델
# 필요한 라이브러리 불러오기
import pandas as pd
from sklearn.model_selection import train_test_split # 데이터 분리
from sklearn.ensemble import VotingClassifier, BaggingClassifier, AdaBoostClassifier # 앙상블 모델
from sklearn.linear_model import LogisticRegression # 로지스틱 회귀
from sklearn.tree import DecisionTreeClassifier # 의사결정 나무
from sklearn.svm import SVC # 서포트 벡터 머신
from sklearn.metrics import accuracy_score, classification_report # 평가 지표
# 1. 데이터 로드 및 분리
data = pd.read_csv('datasets/heart.csv') # 데이터 로드
X = data.drop('output', axis=1) # 독립 변수
y = data['output'] # 종속 변수
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42) # 데이터 분리
# 2. 보팅 앙상블
# 개별 모델 생성
model1 = LogisticRegression(max_iter=1000) # 로지스틱 회귀
model2 = DecisionTreeClassifier(max_depth=4) # 의사결정 나무
model3 = SVC(probability=True) # 서포트 벡터 머신 (확률 계산 가능)
# 보팅 모델 생성 (소프트 보팅)
voting_clf = VotingClassifier(
estimators=[('lr', model1), ('dt', model2), ('svc', model3)],
voting='soft'
)
voting_clf.fit(X_train, y_train) # 모델 학습
y_pred_voting = voting_clf.predict(X_test) # 예측
accuracy_voting = accuracy_score(y_test, y_pred_voting) # 정확도 계산
# 3. 배깅 앙상블
# 배깅 모델 생성
bagging_clf = BaggingClassifier(
estimator=DecisionTreeClassifier(),
n_estimators=10, # 10개의 의사결정 나무
random_state=42
)
bagging_clf.fit(X_train, y_train) # 모델 학습
y_pred_bagging = bagging_clf.predict(X_test) # 예측
accuracy_bagging = accuracy_score(y_test, y_pred_bagging) # 정확도 계산
# 4. 부스팅 앙상블
# 부스팅 모델 생성
boosting_clf = AdaBoostClassifier(
estimator=DecisionTreeClassifier(max_depth=2),
n_estimators=50, # 50개의 약한 학습기
random_state=42
)
boosting_clf.fit(X_train, y_train) # 모델 학습
y_pred_boosting = boosting_clf.predict(X_test) # 예측
accuracy_boosting = accuracy_score(y_test, y_pred_boosting) # 정확도 계산
# 5. 결과 출력
print("Voting Classifier Accuracy:", accuracy_voting)
print("Bagging Classifier Accuracy:", accuracy_bagging)
print("Boosting Classifier Accuracy:", accuracy_boosting)
print("\nClassification Report (Voting):\n", classification_report(y_test, y_pred_voting))
print("\nClassification Report (Bagging):\n", classification_report(y_test, y_pred_bagging))
print("\nClassification Report (Boosting):\n", classification_report(y_test, y_pred_boosting))
앙상블모델 - 보팅, 배깅, 부스팅 종류 다양하게
# 다양한 앙상블 모델 (Voting, Bagging, Boosting) 튜토리얼
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.ensemble import VotingClassifier, BaggingClassifier, AdaBoostClassifier, GradientBoostingClassifier
from xgboost import XGBClassifier
from lightgbm import LGBMClassifier
from catboost import CatBoostClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.svm import SVC
from sklearn.metrics import accuracy_score, classification_report
# 1️⃣ 데이터 불러오기
data = pd.read_csv("datasets/heart.csv")
# 2️⃣ 특성(X)과 타겟(y) 분리
X = data.drop(columns=["output"])
y = data["output"]
# 3️⃣ 데이터 나누기 (훈련 데이터와 테스트 데이터)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# 4️⃣ 개별 모델 정의
model1 = LogisticRegression(max_iter=1000, random_state=42)
model2 = DecisionTreeClassifier(max_depth=3, random_state=42)
model3 = SVC(probability=True, random_state=42)
# 5️⃣ Voting Classifier (소프트 보팅)
voting_clf = VotingClassifier(
estimators=[('lr', model1), ('dt', model2), ('svc', model3)], voting='soft'
)
voting_clf.fit(X_train, y_train)
y_pred_voting = voting_clf.predict(X_test)
print("Voting Classifier Accuracy:", accuracy_score(y_test, y_pred_voting))
# 6️⃣ Bagging Classifier (배깅)
bagging_clf = BaggingClassifier(
base_estimator=DecisionTreeClassifier(), n_estimators=10, random_state=42
)
bagging_clf.fit(X_train, y_train)
y_pred_bagging = bagging_clf.predict(X_test)
print("Bagging Classifier Accuracy:", accuracy_score(y_test, y_pred_bagging))
# 7️⃣ AdaBoost Classifier (부스팅 - AdaBoost)
boosting_clf = AdaBoostClassifier(
base_estimator=DecisionTreeClassifier(max_depth=2), n_estimators=50, random_state=42
)
boosting_clf.fit(X_train, y_train)
y_pred_ada = boosting_clf.predict(X_test)
print("AdaBoost Classifier Accuracy:", accuracy_score(y_test, y_pred_ada))
# 8️⃣ Gradient Boosting Machine (GBM)
gbm_clf = GradientBoostingClassifier(
n_estimators=50, learning_rate=0.1, max_depth=3, random_state=42
)
gbm_clf.fit(X_train, y_train)
y_pred_gbm = gbm_clf.predict(X_test)
print("Gradient Boosting Classifier Accuracy:", accuracy_score(y_test, y_pred_gbm))
# 9️⃣ XGBoost Classifier
xgb_clf = XGBClassifier(
n_estimators=50, learning_rate=0.1, max_depth=3,
objective="binary:logistic", use_label_encoder=False,
eval_metric="logloss", random_state=42
)
xgb_clf.fit(X_train, y_train)
y_pred_xgb = xgb_clf.predict(X_test)
print("XGBoost Classifier Accuracy:", accuracy_score(y_test, y_pred_xgb))
# 🔟 LightGBM Classifier
lgbm_clf = LGBMClassifier(
n_estimators=50, learning_rate=0.1, max_depth=-1, random_state=42
)
lgbm_clf.fit(X_train, y_train)
y_pred_lgbm = lgbm_clf.predict(X_test)
print("LightGBM Classifier Accuracy:", accuracy_score(y_test, y_pred_lgbm))
# 1️⃣1️⃣ CatBoost Classifier
catboost_clf = CatBoostClassifier(
iterations=50, learning_rate=0.1, depth=6, verbose=0, random_state=42
)
catboost_clf.fit(X_train, y_train)
y_pred_catboost = catboost_clf.predict(X_test)
print("CatBoost Classifier Accuracy:", accuracy_score(y_test, y_pred_catboost))
# 🎯 최종 정리
# - Voting Classifier (소프트 보팅)
# - Bagging Classifier (배깅)
# - AdaBoost (부스팅)
# - Gradient Boosting (GBM)
# - XGBoost
# - LightGBM
# - CatBoost
랜덤포레스트모델
# 필요한 라이브러리 불러오기
import pandas as pd # 데이터 처리
from sklearn.model_selection import train_test_split # 데이터 분리
from sklearn.ensemble import RandomForestClassifier # 랜덤 포레스트 모델
from sklearn.metrics import accuracy_score, classification_report # 평가 지표
import matplotlib.pyplot as plt # 시각화
# 1. 데이터 로드 및 분리
data = pd.read_csv('datasets/heart.csv') # 데이터 로드
X = data.drop('output', axis=1) # 입력 변수
y = data['output'] # 출력 변수 (심장병 여부)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42) # 데이터 분리
# 2. 랜덤 포레스트 모델 생성 및 학습
rf_model = RandomForestClassifier(
n_estimators=100, # 100개의 의사결정 나무
max_depth=5, # 트리의 최대 깊이 제한
random_state=42 # 결과 재현성 유지
)
rf_model.fit(X_train, y_train) # 모델 학습
# 3. 테스트 데이터로 예측
y_pred = rf_model.predict(X_test)
# 4. 모델 평가
accuracy = accuracy_score(y_test, y_pred) # 정확도 계산
report = classification_report(y_test, y_pred) # 정밀도, 재현율, F1-스코어
print("Random Forest Accuracy:", accuracy)
print("\nClassification Report:\n", report)
# 5. 특성 중요도 시각화
feature_importances = rf_model.feature_importances_ # 특성 중요도 계산
features = X.columns
# 시각화
plt.figure(figsize=(10, 6))
plt.barh(features, feature_importances, color='skyblue')
plt.title("Feature Importance")
plt.xlabel("Importance Score")
plt.ylabel("Features")
plt.show()
랜덤포레스트모델 - 변수중요도
# 특성 중요도 계산 및 정렬
import numpy as np
feature_importances = rf_model.feature_importances_ # 특성 중요도 계산
features = X.columns
# 정렬
sorted_idx = np.argsort(feature_importances)[::-1] # 중요도 내림차순 정렬
sorted_features = features[sorted_idx]
sorted_importances = feature_importances[sorted_idx]
# 표 형태로 출력
print("Feature Importances (Descending Order):")
for feature, importance in zip(sorted_features, sorted_importances):
print(f"{feature}: {importance:.4f}")
# 시각화
plt.figure(figsize=(10, 6))
plt.barh(sorted_features, sorted_importances, color='skyblue')
plt.title("Feature Importance")
plt.xlabel("Importance Score")
plt.ylabel("Features")
plt.gca().invert_yaxis() # 가장 중요한 특성이 위로 오도록 설정
plt.show()
부스팅모델만 따로
# 다양한 부스팅 모델 (AdaBoost, Gradient Boosting, XGBoost, LightGBM, CatBoost) 튜토리얼
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.ensemble import AdaBoostClassifier, GradientBoostingClassifier
from xgboost import XGBClassifier
from lightgbm import LGBMClassifier
from catboost import CatBoostClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score, classification_report
# 1️⃣ 데이터 불러오기
data = pd.read_csv("datasets/heart.csv")
# 2️⃣ 특성(X)과 타겟(y) 분리
X = data.drop(columns=["output"])
y = data["output"]
# 3️⃣ 데이터 나누기 (훈련 데이터와 테스트 데이터)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# 4️⃣ AdaBoost Classifier
ada_clf = AdaBoostClassifier(
base_estimator=DecisionTreeClassifier(max_depth=2),
n_estimators=50, # 약한 학습기 50개 사용
learning_rate=0.1, # 학습률 설정
random_state=42
)
ada_clf.fit(X_train, y_train)
y_pred_ada = ada_clf.predict(X_test)
print("AdaBoost Classifier Accuracy:", accuracy_score(y_test, y_pred_ada))
# 5️⃣ Gradient Boosting Machine (GBM)
gbm_clf = GradientBoostingClassifier(
n_estimators=50, # 부스팅 스테이지 개수
learning_rate=0.1, # 학습률
max_depth=3, # 트리 깊이
random_state=42
)
gbm_clf.fit(X_train, y_train)
y_pred_gbm = gbm_clf.predict(X_test)
print("Gradient Boosting Classifier Accuracy:", accuracy_score(y_test, y_pred_gbm))
# 6️⃣ XGBoost Classifier
xgb_clf = XGBClassifier(
n_estimators=50, # 트리 개수
learning_rate=0.1, # 학습률
max_depth=3, # 트리 깊이
objective="binary:logistic", # 이진 분류 문제
use_label_encoder=False, # 경고 방지
eval_metric="logloss", # 평가 지표
random_state=42
)
xgb_clf.fit(X_train, y_train)
y_pred_xgb = xgb_clf.predict(X_test)
print("XGBoost Classifier Accuracy:", accuracy_score(y_test, y_pred_xgb))
# 7️⃣ LightGBM Classifier
lgbm_clf = LGBMClassifier(
n_estimators=50, # 트리 개수
learning_rate=0.1, # 학습률
max_depth=-1, # 자동 설정
random_state=42
)
lgbm_clf.fit(X_train, y_train)
y_pred_lgbm = lgbm_clf.predict(X_test)
print("LightGBM Classifier Accuracy:", accuracy_score(y_test, y_pred_lgbm))
# 8️⃣ CatBoost Classifier
catboost_clf = CatBoostClassifier(
iterations=50, # 학습 반복 횟수
learning_rate=0.1, # 학습률
depth=6, # 트리 깊이
verbose=0, # 학습 로그 최소화
random_state=42
)
catboost_clf.fit(X_train, y_train)
y_pred_catboost = catboost_clf.predict(X_test)
print("CatBoost Classifier Accuracy:", accuracy_score(y_test, y_pred_catboost))
# 🎯 최종 정리
# - AdaBoost: 약한 학습기 여러 개를 결합하여 성능 개선
# - Gradient Boosting: 잔차를 학습하여 성능을 향상
# - XGBoost: GBM을 개선한 고성능 부스팅 알고리즘
# - LightGBM: 대규모 데이터에서 빠른 연산을 위한 부스팅
# - CatBoost: 범주형 데이터를 효과적으로 처리하는 부스팅