[파이썬 기초] scikit-learn 기초 (분류, 회귀, 클러스터링)

scikit-learn은 파이썬 머신러닝의 표준 라이브러리입니다.

분류, 회귀, 클러스터링, 차원 축소, 전처리, 모델 평가까지 일관된 API로 제공합니다.

생물정보학에서는 유전자 발현 데이터 분류, 변이 우선순위 지정, 샘플 클러스터링 등에 활용됩니다.

pip install scikit-learn

---

scikit-learn의 공통 API 구조

scikit-learn의 모든 모델은 동일한 인터페이스를 따릅니다.

from sklearn.모듈 import 모델클래스

model = 모델클래스(하이퍼파라미터)   # 모델 생성
model.fit(X_train, y_train)           # 학습
y_pred = model.predict(X_test)        # 예측
score = model.score(X_test, y_test)   # 평가

 

X는 특성(feature) 행렬, y는 레이블(label) 벡터입니다. X의 shape은 (샘플 수, 특성 수)입니다.

---

데이터 준비: 전처리와 분할

학습/테스트 데이터 분할

from sklearn.model_selection import train_test_split
import numpy as np

# 예시 데이터: 유전자 발현량 (100개 샘플, 50개 유전자)
np.random.seed(42)
X = np.random.randn(100, 50)
y = np.random.randint(0, 2, 100)    # 이진 레이블

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)
print(X_train.shape)    # (80, 50)
print(X_test.shape)     # (20, 50)

 

stratify=y는 클래스 비율을 유지하면서 분할합니다. 클래스 불균형이 있는 경우에 중요합니다.

특성 스케일링

거리 기반 알고리즘(KNN, SVM, 클러스터링)은 특성의 스케일에 민감합니다.

학습 데이터로 스케일러를 fit하고, 테스트 데이터에는 transform만 적용합니다.

from sklearn.preprocessing import StandardScaler, MinMaxScaler

# StandardScaler: 평균 0, 표준편차 1로 변환
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)    # fit + transform
X_test_scaled = scaler.transform(X_test)          # transform만 (fit 없음)

# MinMaxScaler: 0~1 범위로 변환
minmax = MinMaxScaler()
X_train_mm = minmax.fit_transform(X_train)

 

테스트 데이터에 fit_transform()을 사용하면 테스트 데이터 정보가 모델 학습에 누출(data leakage)되므로, 반드시 transform()만 사용해야 합니다.

---

분류 (Classification)

레이블이 범주형인 경우, 새 샘플이 어느 클래스에 속하는지 예측합니다.

로지스틱 회귀 (Logistic Regression)

이름은 회귀지만 분류 알고리즘입니다.

이진 분류와 다중 분류 모두 지원합니다.

from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score, classification_report

model = LogisticRegression(max_iter=1000, random_state=42)
model.fit(X_train_scaled, y_train)
y_pred = model.predict(X_test_scaled)

print(f"정확도: {accuracy_score(y_test, y_pred):.4f}")
print(classification_report(y_test, y_pred))

랜덤 포레스트 (Random Forest)

여러 결정 트리를 앙상블하는 방법으로, 실무에서 자주 쓰이는 강력한 분류기입니다. 스케일링 없이도 잘 작동합니다.

from sklearn.ensemble import RandomForestClassifier

rf = RandomForestClassifier(n_estimators=100, random_state=42, n_jobs=-1)
rf.fit(X_train, y_train)
y_pred = rf.predict(X_test)

print(f"정확도: {accuracy_score(y_test, y_pred):.4f}")

# 특성 중요도
importances = rf.feature_importances_
top_idx = np.argsort(importances)[::-1][:10]
print("상위 10개 중요 특성 인덱스:", top_idx)

SVM (Support Vector Machine)

고차원 데이터에서 강점을 보이는 분류기입니다. 유전체 데이터처럼 특성 수가 많은 경우에 자주 사용됩니다.

from sklearn.svm import SVC

svm = SVC(kernel="rbf", C=1.0, probability=True, random_state=42)
svm.fit(X_train_scaled, y_train)
y_pred = svm.predict(X_test_scaled)
y_prob = svm.predict_proba(X_test_scaled)[:, 1]    # 클래스 1의 확률

print(f"정확도: {accuracy_score(y_test, y_pred):.4f}")

KNN (K-Nearest Neighbors)

가장 가까운 k개의 이웃의 클래스로 예측합니다.

from sklearn.neighbors import KNeighborsClassifier

knn = KNeighborsClassifier(n_neighbors=5)
knn.fit(X_train_scaled, y_train)
y_pred = knn.predict(X_test_scaled)
print(f"정확도: {accuracy_score(y_test, y_pred):.4f}")

분류 평가 지표

from sklearn.metrics import (accuracy_score, precision_score,
                              recall_score, f1_score,
                              confusion_matrix, roc_auc_score)

print(f"정확도(Accuracy):  {accuracy_score(y_test, y_pred):.4f}")
print(f"정밀도(Precision): {precision_score(y_test, y_pred):.4f}")
print(f"재현율(Recall):    {recall_score(y_test, y_pred):.4f}")
print(f"F1 score:          {f1_score(y_test, y_pred):.4f}")
print(f"ROC-AUC:           {roc_auc_score(y_test, y_prob):.4f}")
print("혼동 행렬:")
print(confusion_matrix(y_test, y_pred))

 

클래스 불균형이 있을 때는 정확도(Accuracy)만으로는 모델을 평가하기 어렵습니다. F1 score나 ROC-AUC를 함께 확인하는 것이 좋습니다.

---

회귀 (Regression)

레이블이 연속형 수치인 경우, 값을 예측합니다.

선형 회귀

from sklearn.linear_model import LinearRegression, Ridge, Lasso
from sklearn.metrics import mean_squared_error, r2_score
import numpy as np

# 예시 데이터
np.random.seed(42)
X_reg = np.random.randn(100, 10)
y_reg = X_reg[:, 0] * 3 + X_reg[:, 1] * (-1.5) + np.random.randn(100) * 0.5

X_tr, X_te, y_tr, y_te = train_test_split(X_reg, y_reg,
                                            test_size=0.2, random_state=42)

# 기본 선형 회귀
lr = LinearRegression()
lr.fit(X_tr, y_tr)
y_pred = lr.predict(X_te)

mse = mean_squared_error(y_te, y_pred)
rmse = np.sqrt(mse)
r2 = r2_score(y_te, y_pred)
print(f"RMSE: {rmse:.4f}, R²: {r2:.4f}")

 

정규화 회귀 (Ridge, Lasso)

특성 수가 많거나 다중공선성이 있을 때 과적합을 방지합니다.

# Ridge: L2 정규화 (계수를 작게 만듦)
ridge = Ridge(alpha=1.0)
ridge.fit(X_tr, y_tr)
print(f"Ridge R²: {ridge.score(X_te, y_te):.4f}")

# Lasso: L1 정규화 (불필요한 특성의 계수를 0으로 만듦, 특성 선택 효과)
lasso = Lasso(alpha=0.1)
lasso.fit(X_tr, y_tr)
print(f"Lasso R²: {lasso.score(X_te, y_te):.4f}")
print(f"0이 된 계수 수: {(lasso.coef_ == 0).sum()}")

회귀 평가 지표

지표	의미
MAE	평균 절대 오차
MSE	평균 제곱 오차
RMSE	평균 제곱근 오차 (MSE의 제곱근, 원래 단위)
R²	결정계수 (1에 가까울수록 좋음)

from sklearn.metrics import mean_absolute_error

print(f"MAE:  {mean_absolute_error(y_te, y_pred):.4f}")
print(f"RMSE: {np.sqrt(mean_squared_error(y_te, y_pred)):.4f}")
print(f"R²:   {r2_score(y_te, y_pred):.4f}")

---

클러스터링 (Clustering)

레이블 없이 데이터를 비슷한 것끼리 묶습니다. 비지도 학습입니다.

K-Means

데이터를 k개의 클러스터로 나눕니다. k를 미리 지정해야 합니다.

from sklearn.cluster import KMeans

# 예시: 유전자 발현 데이터 클러스터링
np.random.seed(42)
X_clust = np.vstack([
    np.random.randn(50, 2) + [0, 0],
    np.random.randn(50, 2) + [5, 5],
    np.random.randn(50, 2) + [0, 5],
])

kmeans = KMeans(n_clusters=3, random_state=42, n_init=10)
kmeans.fit(X_clust)
labels = kmeans.labels_

print(f"클러스터 레이블: {set(labels)}")
print(f"클러스터 중심:\n{kmeans.cluster_centers_}")

적절한 k 찾기: 엘보우 방법

import matplotlib.pyplot as plt

inertias = []
k_range = range(1, 11)

for k in k_range:
    km = KMeans(n_clusters=k, random_state=42, n_init=10)
    km.fit(X_clust)
    inertias.append(km.inertia_)

plt.figure(figsize=(7, 4))
plt.plot(k_range, inertias, "bo-")
plt.xlabel("클러스터 수 (k)")
plt.ylabel("Inertia")
plt.title("엘보우 방법으로 최적 k 찾기")
plt.show()

DBSCAN

밀도 기반 클러스터링으로, k를 미리 지정하지 않아도 됩니다. 노이즈(이상치)를 자동으로 탐지합니다.

from sklearn.cluster import DBSCAN

dbscan = DBSCAN(eps=0.5, min_samples=5)
dbscan.fit(X_clust)
labels = dbscan.labels_

n_clusters = len(set(labels)) - (1 if -1 in labels else 0)
n_noise = (labels == -1).sum()
print(f"클러스터 수: {n_clusters}, 노이즈 포인트: {n_noise}")

labels_에서 -1은 노이즈로 분류된 포인트입니다.

계층적 클러스터링 (Hierarchical Clustering)

덴드로그램으로 클러스터 구조를 시각화할 수 있어, 생물정보학에서 히트맵과 함께 자주 사용합니다.

from sklearn.cluster import AgglomerativeClustering
from scipy.cluster.hierarchy import dendrogram, linkage
import matplotlib.pyplot as plt

# 클러스터링
hclust = AgglomerativeClustering(n_clusters=3, linkage="ward")
labels = hclust.fit_predict(X_clust)

# 덴드로그램 시각화 (scipy 사용)
linked = linkage(X_clust, method="ward")
plt.figure(figsize=(10, 4))
dendrogram(linked, truncate_mode="lastp", p=20)
plt.title("Hierarchical Clustering Dendrogram")
plt.xlabel("샘플")
plt.ylabel("거리")
plt.show()

클러스터링 평가

레이블이 없는 비지도 학습이므로 평가가 어렵습니다. 내부 평가 지표를 활용합니다.

from sklearn.metrics import silhouette_score, davies_bouldin_score

# 실루엣 점수: -1~1, 1에 가까울수록 좋음
sil = silhouette_score(X_clust, labels)
print(f"실루엣 점수: {sil:.4f}")

# Davies-Bouldin 점수: 낮을수록 좋음
db = davies_bouldin_score(X_clust, labels)
print(f"Davies-Bouldin 점수: {db:.4f}")

---

교차 검증 (Cross-Validation)

단순한 train/test 분할보다 신뢰할 수 있는 모델 평가 방법입니다.

from sklearn.model_selection import cross_val_score, StratifiedKFold

model = RandomForestClassifier(n_estimators=100, random_state=42)

# 5-fold 교차 검증
cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
scores = cross_val_score(model, X, y, cv=cv, scoring="f1")

print(f"F1 점수: {scores}")
print(f"평균: {scores.mean():.4f} ± {scores.std():.4f}")

---

Pipeline: 전처리 + 모델을 하나로

전처리와 모델을 파이프라인으로 묶으면 데이터 누출 없이 교차 검증을 안전하게 수행할 수 있습니다.

from sklearn.pipeline import Pipeline

pipeline = Pipeline([
    ("scaler", StandardScaler()),
    ("classifier", RandomForestClassifier(n_estimators=100, random_state=42))
])

scores = cross_val_score(pipeline, X, y, cv=5, scoring="f1")
print(f"Pipeline F1: {scores.mean():.4f} ± {scores.std():.4f}")

 

Pipeline을 사용하면 fit()이 호출될 때 각 단계가 순서대로 실행되고, 교차 검증 시 각 fold마다 독립적으로 전처리가 적용되어 데이터 누출을 방지합니다.

---

정리표

작업 대표	알고리즘	클래스
분류	로지스틱 회귀	LogisticRegression
분류	랜덤 포레스트	RandomForestClassifier
분류	SVM	SVC
분류	KNN	KNeighborsClassifier
회귀	선형 회귀	LinearRegression
회귀	Ridge / Lasso	Ridge, Lasso
클러스터링	K-Means	KMeans
클러스터링	DBSCAN	DBSCAN
클러스터링	계층적	AgglomerativeClustering
전처리	표준화	StandardScaler
평가	교차 검증	cross_val_score
통합	파이프라인	Pipeline

---

태그: 파이썬, 파이썬기초, scikit-learn, 머신러닝, 분류, 회귀, 클러스터링, RandomForest, KMeans, DBSCAN, Pipeline, 생물정보학, 데이터분석