Scikit-Learn (sklearn)은 NumPy, SciPy, Matplotlib을 기반으로 구축된 파이썬의 표준 오픈소스 머신러닝 및 통계 모델링 라이브러리입니다. 이 라이브러리의 가장 강력한 특징은 엄격하게 통일된 3대 인터페이스 설계 패턴에 있습니다:
- Estimator (추정기):
fit(X, y)를 통해 데이터로부터 모델 파라미터를 학습합니다. - Transformer (변환기):
transform(X)및fit_transform(X)를 통해 특성을 전처리하고 변환합니다. - Predictor (예측기):
predict(X),predict_proba(X),score(X, y)를 통해 미지의 샘플에 대한 예측을 수행합니다.
🔗 관련 치트시트: NumPy 치트시트 · Pandas 치트시트 · 지도 학습 알고리즘 · 데이터 분석 기법 · Python 치트시트
1. 엔드투엔드 퀵스타트 예제
아래 코드는 데이터셋 로드, 계층화 분할, 특성 스케일링, 모델 학습 및 성능 평가까지의 전체 흐름을 보여줍니다:
from sklearn.datasets import load_iris
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
# 1. 데이터 로드
iris = load_iris()
X, y = iris.data, iris.target
# 2. 계층화 분할 (Train/Test)
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.2, random_state=42, stratify=y
)
# 3. 특성 스케일링 (데이터 누수를 방지하기 위해 반드시 학습 세트에만 fit 수행)
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)
# 4. 추정기 학습
knn = KNeighborsClassifier(n_neighbors=5)
knn.fit(X_train_scaled, y_train)
# 5. 예측 및 평가
y_pred = knn.predict(X_test_scaled)
print(f"Accuracy: {accuracy_score(y_test, y_pred):.4f}")
print(classification_report(y_test, y_pred, target_names=iris.target_names))
2. 데이터 준비 및 분할
Scikit-Learn은 2차원 수치 구조를 기본 입력으로 요구합니다: (n_samples, n_features) 형태의 특성 행렬 $X$와 (n_samples,) 형태의 타깃 벡터 $y$입니다. 입력으로는 NumPy ndarray, SciPy 희소 행렬(scipy.sparse), Pandas DataFrame/Series를 지원합니다.
2.1 내장 데이터셋 및 가상 데이터 생성
from sklearn import datasets
# 소규모 벤치마크용 토이 데이터셋 (Bunch 객체 반환)
iris = datasets.load_iris() # 다중 클래스 분류
digits = datasets.load_digits() # 8x8 손글씨 숫자 이미지
diabetes = datasets.load_diabetes() # 회귀 벤치마크
wine = datasets.load_wine() # 와인 화학 성분 3분류
# 실무 벤치마크 데이터셋 (로컬 캐싱)
housing = datasets.fetch_california_housing()
# 알고리즘 검증을 위한 가상 데이터 생성
X, y = datasets.make_classification(
n_samples=1000, n_features=20, n_informative=15, n_classes=2, random_state=42
)
X_reg, y_reg = datasets.make_regression(n_samples=500, n_features=10, noise=0.1, random_state=42)
X_blob, y_blob = datasets.make_blobs(n_samples=300, centers=3, n_features=2, random_state=42)
2.2 데이터셋 분할 (train_test_split)
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(
X, y,
test_size=0.25, # 테스트 세트 비율 (기본값: 0.25)
random_state=42, # 재현성을 위한 시드 고정
shuffle=True, # 분할 전 샘플 셔플
stratify=y # 분류 작업 권장: 클래스 비율 유지
)
3. 특성 공학 및 전처리 (sklearn.preprocessing & sklearn.impute)
| 변환기 (Transformer) | 사용 목적 | 수학적 변환 / 동작 로직 | 핵심 매개변수 |
|---|---|---|---|
StandardScaler |
수치형 특성의 Z-점수 표준화 | $z = \frac{x - \mu}{\sigma}$ (평균 0, 분산 1) | with_mean=True, with_std=True |
MinMaxScaler |
특성을 지정된 닫힌 구간으로 정규화 | $x' = \frac{x - x_{\min}}{x_{\max} - x_{\min}} \cdot (\max - \min) + \min$ | feature_range=(0, 1) |
RobustScaler |
이상치에 강건한 스케일링 | 사분위수 범위 기반 스케일링: $x' = \frac{x - Q_2}{Q_3 - Q_1}$ | quantile_range=(25.0, 75.0) |
Normalizer |
샘플(행 벡터) 단위 정규화 | 각 샘플의 $L_1$, $L_2$ 또는 최대 노름을 1로 변환 | norm='l2' ('l1', 'max') |
Binarizer |
임계값 기반 이진화 | $x > \text{threshold} \Rightarrow 1$, 그 외 $0$ | threshold=0.0 |
SimpleImputer |
결측값 대체 | 평균, 중앙값, 최빈값 또는 상수로 결측값 대체 | missing_values=np.nan, strategy='mean' |
OneHotEncoder |
명목형 범주 특성 원-핫 인코딩 | 범주형 변수를 이진 더미 열로 변환 | drop='first', handle_unknown='ignore' |
OrdinalEncoder |
순서형 범주 특성 정수 인코딩 | 범주형 변수를 순서 있는 정수 $0, \dots, K-1$로 변환 | categories='auto', encoded_missing_value |
LabelEncoder |
타깃 변수 $y$ 라벨 인코딩 | 문자열 라벨을 정수 $0 \dots C-1$로 변환 | 타깃 변수 $y$ 전용 (특성 $X$에는 절대 사용 금지) |
PolynomialFeatures |
다항식 및 상호작용 특성 생성 | 다항식 조합 특성 $[1, a, b, a^2, ab, b^2]$ 생성 | degree=2, include_bias=False |
3.1 전처리 코드 예제
import numpy as np
from sklearn.preprocessing import (
StandardScaler, MinMaxScaler, RobustScaler, Normalizer,
Binarizer, OneHotEncoder, OrdinalEncoder, LabelEncoder, PolynomialFeatures
)
from sklearn.impute import SimpleImputer
# 1. 수치형 표준화 (테스트 데이터에는 절대 fit을 호출하지 마세요!)
scaler = StandardScaler()
X_train_std = scaler.fit_transform(X_train)
X_test_std = scaler.transform(X_test)
# 2. 결측값 대체 (중앙값 전략)
imputer = SimpleImputer(missing_values=np.nan, strategy='median')
X_train_imp = imputer.fit_transform(X_train)
X_test_imp = imputer.transform(X_test)
# 3. 범주형 원-핫 인코딩 (미지의 테스트 카테고리 안전 처리)
ohe = OneHotEncoder(handle_unknown='ignore', sparse_output=False)
X_train_ohe = ohe.fit_transform(X_train_cat)
X_test_ohe = ohe.transform(X_test_cat)
# 4. 타깃 변수 라벨 인코딩
le = LabelEncoder()
y_train_enc = le.fit_transform(y_train)
y_test_enc = le.transform(y_test)
# 5. 다항식 특성 확장
poly = PolynomialFeatures(degree=2, include_bias=False)
X_train_poly = poly.fit_transform(X_train)
4. 대표 추정기 마스터 인덱스
4.1 지도 학습: 분류 (Classification)
from sklearn.linear_model import LogisticRegression
from sklearn.neighbors import KNeighborsClassifier
from sklearn.svm import SVC
from sklearn.naive_bayes import GaussianNB
from sklearn.ensemble import RandomForestClassifier, HistGradientBoostingClassifier
# 로지스틱 회귀 (선형 분류 기준 모델)
clf_lr = LogisticRegression(C=1.0, max_iter=200, random_state=42)
# K-최근접 이웃 (KNN)
clf_knn = KNeighborsClassifier(n_neighbors=5, metric='minkowski', p=2)
# 서포트 벡터 머신 (RBF 커널)
clf_svm = SVC(C=1.0, kernel='rbf', gamma='scale', probability=True, random_state=42)
# 가우시안 나이브 베이즈
clf_gnb = GaussianNB()
# 랜덤 포레스트 (배깅 앙상블)
clf_rf = RandomForestClassifier(n_estimators=100, max_depth=None, n_jobs=-1, random_state=42)
# 히스토그램 기반 그래디언트 부스팅 (LightGBM급 고속 GBDT)
clf_hgb = HistGradientBoostingClassifier(learning_rate=0.1, max_iter=100, random_state=42)
4.2 지도 학습: 회귀 (Regression)
from sklearn.linear_model import LinearRegression, Ridge, Lasso
from sklearn.svm import SVR
from sklearn.ensemble import RandomForestRegressor, HistGradientBoostingRegressor
# 최소제곱법 선형 회귀 (OLS)
reg_lr = LinearRegression()
# 릿지 회귀 (L2 정규화: 다중공선성 방지)
reg_ridge = Ridge(alpha=1.0)
# 라쏘 회귀 (L1 정규화: 희소 특성 선택)
reg_lasso = Lasso(alpha=0.1)
# 서포트 벡터 회귀 (SVR)
reg_svr = SVR(kernel='rbf', C=1.0, epsilon=0.1)
# 랜덤 포레스트 회귀
reg_rf = RandomForestRegressor(n_estimators=100, n_jobs=-1, random_state=42)
4.3 비지도 학습: 군집화 및 차원 축소
from sklearn.cluster import KMeans, DBSCAN
from sklearn.decomposition import PCA
# K-평균 군집화 (K-Means)
kmeans = KMeans(n_clusters=3, init='k-means++', n_init=10, random_state=42)
kmeans.fit(X)
cluster_labels = kmeans.labels_ # 군집 할당 레이블
cluster_centers = kmeans.cluster_centers_
# 밀도 기반 공간 군집화 (DBSCAN: 노이즈 저항, 임의 형태 군집)
dbscan = DBSCAN(eps=0.5, min_samples=5)
db_labels = dbscan.fit_predict(X) # -1은 이상치/노이즈를 나타냄
# 주성분 분석 (PCA)
pca = PCA(n_components=0.95) # 누적 설명 분산 비율 95% 보존
X_pca = pca.fit_transform(X)
print("보존된 주성분 수:", pca.n_components_)
print("설명된 분산 비율:", pca.explained_variance_ratio_)
5. 통일 API 연산 치트시트
| 연산 카테고리 | 대표 메서드 | 대상 객체 유형 | 동작 의미 및 반환값 |
|---|---|---|---|
| 학습 (Fit) | estimator.fit(X, y) |
모든 Estimator | 학습 데이터로부터 파라미터를 추정하고 self 반환 |
| 예측 (Predict) | predictor.predict(X) |
모든 Predictor | 클래스 라벨 또는 연속형 타깃 예측값 생성 |
| 확률 예측 (Probability) | predictor.predict_proba(X) |
분류기 | 사후 클래스 확률 분포 행렬 반환 |
| 결정 경계 거리 | predictor.decision_function(X) |
선형 모델 / SVM | 샘플과 초평면 사이의 부호 있는 거리 반환 |
| 변환 (Transform) | transformer.transform(X) |
모든 Transformer | 학습된 파라미터를 기반으로 특성 변환 및 투영 |
| 학습 및 변환 | transformer.fit_transform(X) |
모든 Transformer | 파라미터 학습과 특성 변환을 단일 단계로 최적화 수행 |
| 기본 점수 산출 | estimator.score(X, y) |
분류기 / 회귀기 | 분류의 경우 정확도(Accuracy), 회귀의 경우 결정계수($R^2$) 반환 |
6. 평가 지표 (sklearn.metrics)
6.1 분류 평가 지표
from sklearn.metrics import (
accuracy_score, precision_score, recall_score, f1_score,
roc_auc_score, confusion_matrix, classification_report,
ConfusionMatrixDisplay
)
# 1. 하드 라벨 분류 지표 (다중 클래스인 경우 average 지정)
acc = accuracy_score(y_test, y_pred)
prec = precision_score(y_test, y_pred, average='macro')
rec = recall_score(y_test, y_pred, average='macro')
f1 = f1_score(y_test, y_pred, average='macro')
# 2. 연속형 랭킹 지표 (ROC-AUC는 예측 확률 필요)
y_prob = clf.predict_proba(X_test)[:, 1] # 양성 클래스 확률
auc = roc_auc_score(y_test, y_prob)
# 3. 혼동 행렬 및 종합 분류 보고서
cm = confusion_matrix(y_test, y_pred)
print(classification_report(y_test, y_pred))
# 4. 혼동 행렬 시각화 출력
disp = ConfusionMatrixDisplay(confusion_matrix=cm)
disp.plot()
6.2 회귀 평가 지표
from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score
mae = mean_absolute_error(y_test, y_pred)
mse = mean_squared_error(y_test, y_pred)
rmse = mean_squared_error(y_test, y_pred, squared=False) # 평균 제곱근 오차 (RMSE)
r2 = r2_score(y_test, y_pred) # 결정계수 R²
6.3 군집화 평가 지표
from sklearn.metrics import (
adjusted_rand_score, homogeneity_score, v_measure_score, silhouette_score
)
# 외부 검증 (실제 라벨이 존재하는 경우)
ari = adjusted_rand_score(y_true, cluster_labels) # 범위: [-1, 1], 높을수록 우수
homo = homogeneity_score(y_true, cluster_labels) # 범위: [0, 1]
vm = v_measure_score(y_true, cluster_labels) # 동질성과 완전성의 조화 평균
# 내부 검증 (기하 구조 기반, 실제 라벨 불필요)
sil = silhouette_score(X, cluster_labels) # 범위: [-1, 1], 1에 가까울수록 명확한 군집
7. 교차 검증 및 하이퍼파라미터 튜닝 (sklearn.model_selection)
7.1 교차 검증 (Cross-Validation)
from sklearn.model_selection import cross_val_score, cross_validate, StratifiedKFold
# 표준 K-Fold 교차 검증
scores = cross_val_score(clf, X, y, cv=5, scoring='accuracy')
print(f"5-Fold CV Accuracy: {scores.mean():.4f} (±{scores.std():.4f})")
# 계층화 K-Fold (Stratified K-Fold) 생성기
skf = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
scores_skf = cross_val_score(clf, X, y, cv=skf, scoring='f1_macro')
# 다중 지표 동시 평가
multi_scores = cross_validate(
clf, X, y, cv=5,
scoring=['accuracy', 'roc_auc'],
return_train_score=False
)
print("평균 검증 AUC:", multi_scores['test_roc_auc'].mean())
7.2 그리드 서치 및 랜덤 서치
from sklearn.model_selection import GridSearchCV, RandomizedSearchCV
from scipy.stats import randint
# 1. 완전 탐색 그리드 서치 (GridSearchCV)
param_grid = {
'n_neighbors': [3, 5, 7, 11],
'weights': ['uniform', 'distance'],
'metric': ['euclidean', 'manhattan']
}
grid = GridSearchCV(
estimator=KNeighborsClassifier(),
param_grid=param_grid,
cv=5,
scoring='accuracy',
n_jobs=-1
)
grid.fit(X_train, y_train)
print("최적 파라미터:", grid.best_params_)
best_model = grid.best_estimator_
# 2. 랜덤 파라미터 서치 (RandomizedSearchCV: 파라미터 탐색 공간이 큰 경우)
param_dist = {
'n_estimators': randint(50, 300),
'max_depth': [None, 5, 10, 20],
'min_samples_split': randint(2, 11)
}
rand_search = RandomizedSearchCV(
estimator=RandomForestClassifier(random_state=42),
param_distributions=param_dist,
n_iter=20, # 무작위 조합 후보 수
cv=5,
scoring='accuracy',
random_state=42,
n_jobs=-1
)
rand_search.fit(X_train, y_train)
print("최적 랜덤 서치 파라미터:", rand_search.best_params_)
8. 실무 모범 사례: Pipeline 및 ColumnTransformer
8.1 Pipeline이 필수적인 이유
데이터 분할 또는 교차 검증을 수행하기 전에 전체 데이터셋에 걸쳐 스케일링이나 결측값 대체를 전역적으로 적용하면 **데이터 누수(Data Leakage)**가 발생합니다. 검증 세트의 정보가 학습 통계치에 스며들어 오프라인에서는 지나치게 낙관적인 점수를 얻지만 실무 배포 시 심각한 성능 저하가 발생합니다.
Pipeline은 전처리 변환기와 추정기를 하나의 분리 불가능한 단위로 결합합니다. 교차 검증 중에도 변환기는 각 폴드의 학습 데이터에서만 fit되고, 검증 데이터에는 오직 transform만 자동으로 적용됩니다.
8.2 프로덕션용 ColumnTransformer 구성 예제
실제 정형 데이터는 연속형 수치 열과 범주형 변수가 혼합되어 있습니다:
from sklearn.compose import ColumnTransformer
from sklearn.pipeline import Pipeline
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.ensemble import RandomForestClassifier
# 1. 특성 컬럼 명시적 분리
numeric_features = ['age', 'income', 'credit_score']
categorical_features = ['gender', 'occupation', 'city']
# 2. 수치형 하위 파이프라인: 중앙값 대체 -> 표준화 스케일링
numeric_transformer = Pipeline(steps=[
('imputer', SimpleImputer(strategy='median')),
('scaler', StandardScaler())
])
# 3. 범주형 하위 파이프라인: 상수 대체 -> 원-핫 인코딩
categorical_transformer = Pipeline(steps=[
('imputer', SimpleImputer(strategy='constant', fill_value='missing')),
('onehot', OneHotEncoder(handle_unknown='ignore', sparse_output=False))
])
# 4. 통합 ColumnTransformer 바인딩
preprocessor = ColumnTransformer(transformers=[
('num', numeric_transformer, numeric_features),
('cat', categorical_transformer, categorical_features)
])
# 5. 엔드투엔드 전체 모델 파이프라인 구성
full_pipeline = Pipeline(steps=[
('preprocessor', preprocessor),
('classifier', RandomForestClassifier(n_estimators=100, random_state=42))
])
# 6. 원자적 학습 및 추론 (누수 제로, 안정적인 배포)
full_pipeline.fit(X_train_df, y_train)
y_pred = full_pipeline.predict(X_test_df)
print("파이프라인 테스트 정확도:", full_pipeline.score(X_test_df, y_test))