はじめに
機械学習とは
機械学習は、手書きのルールに従うのではなくデータから汎化するシステムを構築します。3 つのパラダイム(教師あり、教師なし、強化学習)が、ほとんどの現実の問題をカバーします。構造化されたワークフローに従うこと — 特にきれいなテストセットを手元に確保すること — が、評価への過剰適合という最大の罪を防ぎます。
# Machine Learning: systems that learn patterns from data
# instead of being explicitly programmed.
# Three main paradigms:
# - Supervised: learn f: X -> y from labeled (X, y) pairs
# - Unsupervised: find structure in unlabeled X
# - Reinforcement: learn actions that maximize reward via trial-and-error
# Typical workflow:
# 1. Define problem & collect data
# 2. Preprocess & feature engineering
# 3. Split train / validation / test
# 4. Train model, tune hyperparameters
# 5. Evaluate on test set
# 6. Deploy & monitorコアライブラリ
scikit-learn が表形式/古典 ML の主力です — すべてのアルゴリズムで一貫した fit/predict/transform API を持ちます。データの加工は NumPy と Pandas が、可視化は Matplotlib/Seaborn が扱います。深層学習には、PyTorch(研究向け)か TensorFlow/Keras(本番向け)を選びましょう — どちらも同じ領域をカバーします。
# The standard ML stack in Python
import numpy as np # numerical arrays
import pandas as pd # tabular data
import matplotlib.pyplot as plt # plotting
import seaborn as sns # statistical plots
# scikit-learn: classical ML (trees, SVM, linear models, preprocessing)
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score
# Deep learning (pick one):
import torch # PyTorch
# import tensorflow as tf # TensorFlow/Keras
# Install:
# pip install numpy pandas matplotlib seaborn scikit-learn torchTrain / Validation / Test の分割
最終評価までテストセットに触れては いけません — チューニングに使うと情報が漏れ、報告する指標が膨らみます。クラスのバランスを保つ stratify=y は、不均衡な分類には決定的に重要です。分割を再現可能にするのが random_state です。小さな dataset では、固定の検証セットの代わりに k 分割 CV を使いましょう。
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(
X, y,
test_size=0.2, # 20% held out for test
random_state=42, # reproducibility
stratify=y, # keep class proportions (classification only)
)
# For a third validation set:
X_train, X_temp, y_train, y_temp = train_test_split(
X, y, test_size=0.4, stratify=y, random_state=42)
X_val, X_test, y_val, y_test = train_test_split(
X_temp, y_temp, test_size=0.5, stratify=y_temp, random_state=42)
# Now: 60% train, 20% val, 20% test最初のモデル(Iris)
Iris dataset が ML の「Hello World」です — 花のサンプル 150 個、特徴 4 個、クラス 3 個。このスニペットが定番の sklearn パターンを示します:データのロード、分割、モデルのインスタンス化、fit、predict、評価。classification_report がクラスごとの precision/recall/F1 を与え、不均衡な問題では精度だけよりはるかに情報豊かです。
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, classification_report
iris = load_iris()
X, y = iris.data, iris.target
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.2, stratify=y, random_state=42)
model = RandomForestClassifier(n_estimators=100, random_state=42)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)
print("Accuracy:", accuracy_score(y_test, y_pred))
print(classification_report(y_test, y_pred, target_names=iris.target_names))再現性
重みの初期化とシャッフルが再現可能になるよう、numpy、random、DL フレームワークのシードを設定しましょう。すべての確率的な sklearn 推定器に random_state を渡しましょう。完全な決定性(特に GPU 上)には、決定的なアルゴリズムと env フラグも必要です — 「一致するはず」なのに一致しない 結果のデバッグに有用です。
import numpy as np
import random
import torch
SEED = 42
np.random.seed(SEED)
random.seed(SEED)
torch.manual_seed(SEED)
if torch.cuda.is_available():
torch.cuda.manual_seed_all(SEED)
# For sklearn, pass random_state to each estimator:
# RandomForestClassifier(random_state=SEED)
# Force deterministic operations (slower but fully reproducible):
torch.use_deterministic_algorithms(True)
# Optional: pin GPU non-determinism
import os
os.environ["CUBLAS_WORKSPACE_CONFIG"] = ":4096:8"データの前処理
欠損値の処理
全 dataset で imputer を fit すると、テストの統計が学習へ漏れます — 必ず train のみで fit しましょう。平均より中央値が外れ値に強いです。カテゴリ特徴には 'most_frequent' か 'constant' を使いましょう。KNN 補完は多変量の構造を捉えられますが、大きなデータでは高コストです。欠損自体が情報を運ぶことも検討しましょう('is_missing' のインジケータを追加)。
import pandas as pd
from sklearn.impute import SimpleImputer, KNNImputer
df = pd.DataFrame({"age": [25, np.nan, 35, 45],
"income": [50000, 60000, np.nan, 80000]})
# Drop rows with any missing values (use sparingly)
df_drop = df.dropna()
# Mean/median/mode imputation
imp = SimpleImputer(strategy="median") # 'mean','most_frequent','constant'
df_imputed = pd.DataFrame(imp.fit_transform(df), columns=df.columns)
# KNN imputer (uses similar samples)
knn_imp = KNNImputer(n_neighbors=3)
df_knn = pd.DataFrame(knn_imp.fit_transform(df), columns=df.columns)
# Always fit imputers on TRAINING data only, then transform test
imp.fit(X_train)
X_train_imp = imp.transform(X_train)
X_test_imp = imp.transform(X_test) # uses train mediansスケーリングと正規化
多くのアルゴリズム(SVM、KNN、ロジスティック回帰、ニューラルネット、PCA)はスケールに敏感です — ツリーモデルは一般にそうではありません。デフォルトは StandardScaler で、有界の範囲が必要なとき(画像など)は MinMaxScaler、外れ値が StandardScaler を歪めるなら RobustScaler です。ALWAYS で、train で fit し、同じ fit 済みの scaler で test を transform しましょう — test で fit_transform は決してしないこと。
from sklearn.preprocessing import StandardScaler, MinMaxScaler, RobustScaler
# Standardization: mean 0, std 1 (most common)
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test) # use train mean/std!
# Min-max: scale to [0, 1]
minmax = MinMaxScaler()
X_mm = minmax.fit_transform(X_train)
# Robust to outliers: uses median & IQR
robust = RobustScaler()
X_robust = robust.fit_transform(X_train)カテゴリ変数のエンコード
LabelEncoder はターゲット用で、OneHotEncoder は名義特徴用です(固有の順序がない — one-hot により、red < green < blue を含意するのを避けます)。順序カテゴリ(サイズなど)には OrdinalEncoder です。テスト時に未知のカテゴリでエラーになるのを防ぐのが handle_unknown='ignore' です。高基数のカテゴリ(郵便番号など)には、次元の爆発を避けるため、ターゲット/カウントエンコードの方が向いています。
from sklearn.preprocessing import LabelEncoder, OneHotEncoder, OrdinalEncoder
# Label encode TARGET (classification): strings -> integers
le = LabelEncoder()
y = le.fit_transform(["cat", "dog", "cat", "bird"]) # [0, 1, 0, 2]
le.inverse_transform([0, 1, 2]) # back to strings
# One-hot encode FEATURES (nominal, no order)
ohe = OneHotEncoder(sparse_output=False, handle_unknown="ignore")
X_ohe = ohe.fit_transform(df[["color"]]) # red/green/blue -> 3 cols
# Ordinal encode (ordered categories)
oe = OrdinalEncoder(categories=[["low", "medium", "high"]])
X_ord = oe.fit_transform(df[["size"]])
# For high-cardinality features, consider target encoding
# or just drop them if they're IDs.不均衡データの処理
不均衡なデータがモデルを多数派クラスへ傾けます。最もきれいな修正が class_weight='balanced' です(データの複製なし)。SMOTE が少数派の新しいサンプルを合成しますが、ノイズを作り得ます — train にだけ適用しましょう。オーバーサンプリングとアンダーサンプリングは機能しますが、過剰適合したりデータを失ったりします。評価には必ず precision、recall、F1、AUC を使いましょう — 不均衡データでは精度だけに頼らないこと。
from sklearn.utils import resample
from imblearn.over_sampling import SMOTE
from sklearn.utils.class_weight import compute_class_weight
# 1. Class weights (no resampling — preferred for trees/linear)
classes = np.unique(y_train)
weights = compute_class_weight("balanced", classes=classes, y=y_train)
class_weight = dict(zip(classes, weights))
model = RandomForestClassifier(class_weight=class_weight)
# 2. Oversample minority
df_majority = df[df.y == 0]
df_minority = df[df.y == 1]
df_minority_up = resample(df_minority, replace=True,
n_samples=len(df_majority), random_state=42)
# 3. SMOTE: synthesize new minority samples via k-nearest neighbors
smote = SMOTE(random_state=42)
X_res, y_res = smote.fit_resample(X_train, y_train)
# Always resample on TRAINING data only — never the test set!外れ値検出
外れ値が平均、標準偏差、線形モデルを歪めます。Z-score は速いですが正規性を仮定し、外れ値自体により歪められます(代わりに頑健な IQR を使いましょう)。高次元と非線形の境界を扱うのが Isolation Forest です。ドメインに応じて、外れ値を落とすか、上限を切るか(winsorize)、残すか決めましょう — 外れ値こそが、注目するケース(不正、異常)であることもあります。
import numpy as np
from sklearn.ensemble import IsolationForest
# Z-score: |x - mean| / std > 3 is an outlier
z_scores = np.abs((X - X.mean()) / X.std())
outliers = (z_scores > 3).any(axis=1)
# IQR method (more robust to outliers than z-score)
Q1, Q3 = X.quantile(0.25), X.quantile(0.75)
IQR = Q3 - Q1
outliers_iqr = ((X < (Q1 - 1.5 * IQR)) | (X > (Q3 + 1.5 * IQR))).any(axis=1)
# Isolation Forest (good for high-dimensional data)
iso = IsolationForest(contamination=0.05, random_state=42)
outliers_iso = iso.fit_predict(X) # -1 = outlier, 1 = inlier
# Remove or cap (winsorize) outliers before training
X_clean = X[~outliers]特徴量エンジニアリング
多項式と交互作用の特徴
PolynomialFeatures により、x^2、x*y などを新しい特徴として加え、線形モデルが非線形の関係を捉えられます。純粋な 2 乗を避けたいときに有用なのが interaction_only です。特徴数が組合せ的に爆発するため、過剰適合を防ぐため必ず正則化(Ridge/Lasso)とペアにするか、次元削減の後に使いましょう。
from sklearn.preprocessing import PolynomialFeatures
# Generate degree-2 features including interactions
poly = PolynomialFeatures(degree=2, interaction_only=False,
include_bias=False)
X_poly = poly.fit_transform(X)
# For X = [a, b], produces: [a, b, a^2, a*b, b^2]
# interaction_only=True keeps just [a, b, a*b] — no squares
poly_int = PolynomialFeatures(degree=2, interaction_only=True,
include_bias=False)
X_int = poly_int.fit_transform(X)
# Useful for linear models to capture non-linearity
# WARNING: feature count grows quickly — use with regularizationビニングと離散化
ビニングが連続特徴を離散的なバケットへ変え、モデルが非線形の効果を捉え、外れ値への敏感さを減らす助けになります。等幅ビンの空ビン問題を避けるのが、分位点ビン(等頻度)です。ドメイン固有のビン(年齢層など)が、自動的なものをしばしば上回ります。モデルがバケットを別のカテゴリとして扱えるよう、ビン化された特徴を one-hot エンコードしましょう。
from sklearn.preprocessing import KBinsDiscretizer
import pandas as pd
# Equal-width bins (uniform spacing)
df["age_bin"] = pd.cut(df["age"], bins=5, labels=False)
# Equal-frequency bins (quantiles — same count per bin)
df["age_quantile"] = pd.qcut(df["age"], q=5, labels=False,
duplicates="drop")
# KBinsDiscretizer with strategy
kbd = KBinsDiscretizer(n_bins=5, encode="onehot-dense",
strategy="quantile") # 'uniform','kmeans'
X_binned = kbd.fit_transform(X[["age"]])
# Custom bins with domain knowledge
df["age_group"] = pd.cut(df["age"],
bins=[0, 18, 35, 60, 100],
labels=["child","young","adult","senior"])テキスト特徴の抽出
Bag-of-words のカウントは単純ですが、すべての単語を等しく扱います。文書をまたいで共通する単語の重みを下げるのが TF-IDF です。短いフレーズを捉えるのが ngram_range=(1,2) です。モダンな NLP には、事前学習済みの埋め込み(sentence-transformers、BERT)を使いましょう — bag-of-words では捉えられない意味を捉えます。語彙のサイズとノイズを制御するため、max_features と min_df を必ず設定しましょう。
from sklearn.feature_extraction.text import TfidfVectorizer, CountVectorizer
corpus = [
"machine learning is fun",
"deep learning is a subset of machine learning",
"python is great for data science",
]
# Bag of words (counts)
cv = CountVectorizer(max_features=1000, stop_words="english",
ngram_range=(1, 2))
X_counts = cv.fit_transform(corpus)
# TF-IDF: downweights common words
tfidf = TfidfVectorizer(max_features=1000, stop_words="english",
ngram_range=(1, 2), min_df=2)
X_tfidf = tfidf.fit_transform(corpus)
# For production, consider sentence-transformers for embeddings:
# from sentence_transformers import SentenceTransformer
# model = SentenceTransformer("all-MiniLM-L6-v2")
# embeddings = model.encode(corpus)日付と時刻の特徴
生の datetime の列はモデルにとって無用です — 意味のある部分(時、曜日、月)を抽出しましょう。循環特徴(sin/cos)が連続性を保ちます:時刻 23 が時刻 0 に近いこと。これは生の整数エンコードでは見失われます。人間の周期のパターンを捉えるのが is_weekend と祝日です。時系列の単純なトレンド特徴が days_since です。
import pandas as pd
df["date"] = pd.to_datetime(df["date"])
# Extract calendar parts
df["year"] = df["date"].dt.year
df["month"] = df["date"].dt.month
df["day"] = df["date"].dt.day
df["dayofweek"] = df["date"].dt.dayofweek # 0=Mon
df["dayofyear"] = df["date"].dt.dayofyear
df["hour"] = df["date"].dt.hour
df["is_weekend"] = df["date"].dt.dayofweek >= 5
# Cyclic encoding (preserves continuity: hour 23 -> 0)
df["hour_sin"] = np.sin(2 * np.pi * df["hour"] / 24)
df["hour_cos"] = np.cos(2 * np.pi * df["hour"] / 24)
df["month_sin"] = np.sin(2 * np.pi * df["month"] / 12)
df["month_cos"] = np.cos(2 * np.pi * df["month"] / 12)
# Time elapsed (useful as a trend feature)
df["days_since"] = (df["date"] - df["date"].min()).dt.days特徴選択
特徴が多いほど良いわけではありません — 無関係な特徴がノイズと過剰適合のリスクを加えます。速く統計的なのが SelectKBest で、徹底的だが遅いのが RFE(モデルを繰り返し再学習します)、tree の feature_importances_ を一発のフィルタとして使うのが SelectFromModel です。相関のフィルタが冗長な特徴を安価に取り除きます。選択は TRAINING データ上でだけ行い、同じセレクタを test に適用しましょう。
from sklearn.feature_selection import (SelectKBest, f_classif,
RFE, SelectFromModel)
from sklearn.ensemble import RandomForestClassifier
# 1. Univariate: keep top-k by statistical test
selector = SelectKBest(f_classif, k=10)
X_new = selector.fit_transform(X, y)
selected = selector.get_support(indices=True)
# 2. Recursive Feature Elimination (model-based, iterative)
rfe = RFE(RandomForestClassifier(random_state=42),
n_features_to_select=10)
X_rfe = rfe.fit_transform(X, y)
# 3. Select from model importance
sfm = SelectFromModel(RandomForestClassifier(random_state=42),
threshold="median")
X_sfm = sfm.fit_transform(X, y)
# 4. Correlation filter — drop one of highly-correlated pairs
corr = pd.DataFrame(X).corr().abs()
to_drop = [c for c in corr.columns
if any(corr[c] > 0.95)]
X_filtered = X.drop(columns=to_drop)教師あり学習
線形回帰とロジスティック回帰
線形モデルは速く、解釈可能で、強いベースラインです。LogisticRegression はデフォルトで L2 正則化を使います — C が低いほど正則化が強いです。多クラスには softmax を使います。係数が特徴の重要性を示しますが、それはスケーリング後だけです — スケールされていない特徴は係数を比較不可能にします。複雑なモデルを試す前に、必ず線形のベースラインから始めましょう。
from sklearn.linear_model import LinearRegression, LogisticRegression
# Regression: predict a continuous value
lr = LinearRegression()
lr.fit(X_train, y_train)
y_pred = lr.predict(X_test)
# Inspect coefficients
print("Coef:", lr.coef_, "Intercept:", lr.intercept_)
# Classification: predict a class (uses softmax for multiclass)
clf = LogisticRegression(
penalty="l2", # 'l1' (Lasso), 'elasticnet', None
C=1.0, # inverse of regularization strength
max_iter=1000,
multi_class="multinomial",
)
clf.fit(X_train, y_train)
y_pred = clf.predict(X_test)
y_proba = clf.predict_proba(X_test) # class probabilities決定木とランダムフォレスト
決定木は解釈可能ですが高分散です — データの小さな変化が大きく異なる木を生みます。これを修正するのがランダムフォレストです。ブートストラップサンプルとランダムな特徴の部分集合で学習した多くの木の平均を取ります(bagging)。分類の標準が max_features='sqrt' です。フォレストからの特徴の重要性は、高基数特徴へ偏ります — より公正な見方には permutation_importance を試しましょう。
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier
# Single tree (high variance, easy to overfit)
tree = DecisionTreeClassifier(
max_depth=5, # limit depth to prevent overfitting
min_samples_leaf=10, # min samples per leaf
random_state=42,
)
tree.fit(X_train, y_train)
# Random forest: ensemble of trees on bootstrapped samples
rf = RandomForestClassifier(
n_estimators=200, # number of trees
max_depth=None,
max_features="sqrt", # features per split
n_jobs=-1, # use all CPUs
random_state=42,
)
rf.fit(X_train, y_train)
# Feature importance (averaged across trees)
importances = pd.Series(rf.feature_importances_, index=X.columns)勾配ブースティング(XGBoost / LightGBM)
勾配ブースティングが木を逐次的に構築し、それぞれが前の木の誤りを修正します — 表形式データでは通常最高の性能です。sklearn の GradientBoosting は遅く、そのヒストグラムベースの高速な等価物が HistGradientBoosting です。本番/競技の標準が XGBoost と LightGBM で、ネイティブの欠損値処理と早期停止を持ちます。最適な木の数を見つけるため、検証セット付きの early_stopping を必ず使いましょう。
from sklearn.ensemble import GradientBoostingClassifier, HistGradientBoostingClassifier
import lightgbm as lgb
import xgboost as xgb
# sklearn (slow on large data)
gbm = GradientBoostingClassifier(
n_estimators=200, learning_rate=0.1, max_depth=3, random_state=42)
gbm.fit(X_train, y_train)
# sklearn's faster histogram-based version (like LightGBM)
hgbm = HistGradientBoostingClassifier(
max_iter=200, learning_rate=0.1, max_leaf_nodes=31, random_state=42)
hgbm.fit(X_train, y_train)
# XGBoost (popular in competitions)
xgb_clf = xgb.XGBClassifier(
n_estimators=200, learning_rate=0.1, max_depth=6,
subsample=0.8, colsample_bytree=0.8, n_jobs=-1,
eval_metric="logloss", random_state=42)
xgb_clf.fit(X_train, y_train, eval_set=[(X_val, y_val)], early_stopping_rounds=10)
# LightGBM (fastest on large data)
lgb_clf = lgb.LGBMClassifier(n_estimators=200, learning_rate=0.1, num_leaves=31)
lgb_clf.fit(X_train, y_train, eval_set=(X_val, y_val))サポートベクターマシン
SVM が、クラスを分離する最大マージンの超平面を見つけます — はっきりした境界を持つ小〜中規模の dataset に強力です。特徴のスケーリングは MUST です(SVM は距離ベース)。非線形を扱うのが RBF カーネルで、grid search により C(正則化)と gamma(カーネルの幅)を調整しましょう。SVC はサンプルに対するスケーリングが悪いです(O(n^2)〜O(n^3))— 5 万サンプルを超えるなら LinearSVC か木のアンサンブルを使いましょう。
from sklearn.svm import SVC, SVR
from sklearn.preprocessing import StandardScaler
# SVC requires scaling!
scaler = StandardScaler()
X_train_s = scaler.fit_transform(X_train)
X_test_s = scaler.transform(X_test)
# Kernels: 'linear', 'rbf' (Gaussian), 'poly', 'sigmoid'
svm = SVC(
kernel="rbf",
C=1.0, # regularization (higher = fit harder)
gamma="scale", # kernel width
probability=True, # enable predict_proba (slower)
random_state=42,
)
svm.fit(X_train_s, y_train)
y_pred = svm.predict(X_test_s)
# SVR for regression
svr = SVR(kernel="rbf", C=1.0, epsilon=0.1)
svr.fit(X_train_s, y_train)k-近傍法
KNN が最も単純な ML アルゴリズムです:学習データを保存し、k 個の最近傍の間の投票で予測します。スケーリングが不可欠です(距離ベース)。小さい k = 低バイアス/高分散(過剰適合)、大きい k = 高バイアス/低分散(学習不足)。大きな dataset では予測時に KNN は遅いです — 本番には近似最近傍(FAISS、HNSW)を使いましょう。
from sklearn.neighbors import KNeighborsClassifier, KNeighborsRegressor
# KNN: classify by majority vote of k nearest training samples
knn = KNeighborsClassifier(
n_neighbors=5, # k — try odd values to break ties
weights="uniform", # or 'distance' (closer = more weight)
metric="minkowski", # 'euclidean','manhattan', etc.
p=2, # 2=euclidean, 1=manhattan
n_jobs=-1,
)
knn.fit(X_train_scaled, y_train)
y_pred = knn.predict(X_test_scaled)
# Choose k via cross-validation
from sklearn.model_selection import cross_val_score
for k in [1, 3, 5, 7, 9, 11]:
score = cross_val_score(KNeighborsClassifier(n_neighbors=k),
X_train_scaled, y_train, cv=5).mean()
print(f"k={k}: {score:.3f}")教師なし学習
K-Means クラスタリング
K-Means が、クラスタ内分散を最小化することで、データを k 個の球状クラスタへ分割します。10 個のランダムな初期値からアルゴリズムを実行し最良を保つのが n_init=10 です(デフォルトは sklearn 1.4 で変わりました)。k の選択は、ひじ(inertia)か silhouette スコアで行いましょう(silhouette の方が原理的です)。K-Means は球状で等サイズのクラスタを仮定します — 非球状のクラスタには DBSCAN か Gaussian Mixture を。
from sklearn.cluster import KMeans
from sklearn.metrics import silhouette_score
# Choose k via the elbow method or silhouette score
inertias, silhouettes = [], []
for k in range(2, 11):
km = KMeans(n_clusters=k, n_init=10, random_state=42)
labels = km.fit_predict(X)
inertias.append(km.inertia_)
silhouettes.append(silhouette_score(X, labels))
# Final model with chosen k
kmeans = KMeans(n_clusters=4, n_init=10, random_state=42)
clusters = kmeans.fit_predict(X)
centers = kmeans.cluster_centers_
# Predict cluster for new points
new_labels = kmeans.predict(X_new)DBSCAN(密度ベース)
DBSCAN が、任意の形状のクラスタを見つけ、外れ値(ラベル -1)を自動検出します — k を指定する必要がありません。決定的なパラメータが eps で、k 距離プロット(ソートされた k 最近傍距離の「ひじ」)で調整しましょう。ノイズへの敏感さの制御は min_samples です。密度の変化に DBSCAN は苦手で — それをより よく扱うのが HDBSCAN です。新しいポイントを直接予測できません。再 fit するか、HDBSCAN の approximate_predict を使いましょう。
from sklearn.cluster import DBSCAN
# DBSCAN groups densely-connected points; marks sparse ones as noise (-1)
db = DBSCAN(
eps=0.5, # max distance between points in a cluster
min_samples=5, # min points to form a dense region
metric="euclidean",
)
labels = db.fit_predict(X)
n_clusters = len(set(labels)) - (1 if -1 in labels else 0)
n_noise = list(labels).count(-1)
# Tune eps via the k-distance plot (k = min_samples)
from sklearn.neighbors import NearestNeighbors
nn = NearestNeighbors(n_neighbors=5).fit(X)
distances, _ = nn.kneighbors(X)
distances = np.sort(distances[:, -1])
# DBSCAN doesn't have predict() — refit to predict on new data
# Or use HDBSCAN for a more robust, parameter-light alternative階層的クラスタリング
階層的クラスタリングが、ネストしたクラスタのツリー(樹形図)を構築します — 複数の粒度でクラスタ構造を理解したいときに有用です。樹形図が、任意のクラスタ数のためにどこで切るべきか視覚的に示します。最も一般的な結合方法が 'ward'(クラスタ内分散を最小化)で、'single' は脆いです(連鎖します)。AgglomerativeClustering は約 1 万サンプルを超えるとスケールしません — より大きなデータには K-Means か HDBSCAN を。
from sklearn.cluster import AgglomerativeClustering
from scipy.cluster.hierarchy import dendrogram, linkage
import matplotlib.pyplot as plt
# Compute linkage matrix (for dendrogram)
Z = linkage(X, method="ward") # 'ward','complete','average','single'
# Plot dendrogram to choose number of clusters
plt.figure(figsize=(10, 5))
dendrogram(Z, truncate_mode="level", p=5)
plt.axhline(y=Z[-4, 2], color="r", linestyle="--") # cut at 4 clusters
plt.show()
# Agglomerative clustering with chosen k
agg = AgglomerativeClustering(
n_clusters=4,
linkage="ward", # minimizes variance
metric="euclidean",
)
labels = agg.fit_predict(X)ガウス混合モデル
GMM が K-Means の確率的な対応物です:各クラスタが独自の平均と共分散を持つガウスであり、楕円のクラスタを扱い、ソフトな割り当て(確率)を与えます。最も柔軟なのが covariance_type='full' ですがパラメータが多く、'diag' が良い妥協です。k の選択は BIC で行いましょう(低い方が良い)。GMM は新しいサンプルも生成でき — データ拡張に有用です。
from sklearn.mixture import GaussianMixture
# GMM: probabilistic clustering — each cluster is a Gaussian
gmm = GaussianMixture(
n_components=4,
covariance_type="full", # 'spherical','tied','diag','full'
n_init=10,
random_state=42,
)
gmm.fit(X)
labels = gmm.predict(X)
probs = gmm.predict_proba(X) # soft clustering (responsibilities)
# Generative: sample new data
X_sampled, y_sampled = gmm.sample(100)
# Choose n_components via BIC (lower is better)
bics = []
for k in range(1, 11):
g = GaussianMixture(n_components=k, n_init=10, random_state=42).fit(X)
bics.append(g.bic(X))異常検出
異常検出が、まれで疑わしいアイテムを特定します — 不正、欠陥、侵入。汎用の勝者が Isolation Forest です(速く、スケールが良く、高次元を扱えます)。きれいな「正常」の学習セットがあるときに機能するのが One-Class SVM です。グローバルな手法が見逃す局所的な異常を捉えるのが LOF です。期待される異常率を設定するのが contamination で、ドメイン知識に基づき調整しましょう。
from sklearn.ensemble import IsolationForest
from sklearn.svm import OneClassSVM
from sklearn.neighbors import LocalOutlierFactor
# Isolation Forest: isolates anomalies with shallow trees
iso = IsolationForest(contamination=0.05, random_state=42)
labels = iso.fit_predict(X) # -1 anomaly, 1 normal
scores = iso.decision_function(X) # lower = more anomalous
# One-Class SVM: learns a boundary around normal data
ocsvm = OneClassSVM(kernel="rbf", nu=0.05, gamma="scale")
labels = ocsvm.fit_predict(X_train_normal)
# Local Outlier Factor: density-based (good for local anomalies)
lof = LocalOutlierFactor(n_neighbors=20, contamination=0.05)
labels = lof.fit_predict(X)
# For new data: lof.negative_outlier_factor_ (lower = more anomalous)回帰
線形回帰と正則化版
OLS が正則化なしで二乗誤差を最小化します — 多重共線データでは高分散です。L2 の Ridge が係数を滑らかに縮めます — 多くの特徴がそれぞれ効くときに良いです。L1 の Lasso がいくつかの係数をゼロへ押し込み、特徴選択を行います。両者を混ぜた ElasticNet が、特徴が相関しているときに有用です。ペナルティが特徴間で公平になるよう、正則化回帰の前には必ず特徴をスケールしましょう。
from sklearn.linear_model import LinearRegression, Ridge, Lasso, ElasticNet
# Ordinary Least Squares
ols = LinearRegression()
ols.fit(X_train, y_train)
# Ridge (L2): shrinks coefficients, keeps all features
ridge = Ridge(alpha=1.0)
ridge.fit(X_train_scaled, y_train)
# Lasso (L1): shrinks some coefficients to 0 (feature selection)
lasso = Lasso(alpha=0.1, max_iter=10000)
lasso.fit(X_train_scaled, y_train)
print("Non-zero coefs:", (lasso.coef_ != 0).sum())
# ElasticNet: mix of L1 and L2
en = ElasticNet(alpha=0.1, l1_ratio=0.5) # l1_ratio=1 -> pure Lasso
en.fit(X_train_scaled, y_train)回帰の評価指標
RMSE が大きな誤差を(二乗で)罰し、y と同じ単位です — 最もよくある指標です。MAE がより解釈しやすく外れ値に頑健です。R2 が説明された分散の割合であり、0 はモデルが平均の予測と変わらないことを意味します。y=0 のとき未定義になるのが、パーセンテージの誤差を与える MAPE です。ビジネスコストに基づき指標を選びましょう:大きな誤差が壊滅的なら RMSE、すべての誤差が等しく高くつくなら MAE です。
from sklearn.metrics import (mean_squared_error, mean_absolute_error,
r2_score, mean_absolute_percentage_error)
y_pred = model.predict(X_test)
mse = mean_squared_error(y_test, y_pred) # sensitive to outliers
rmse = np.sqrt(mse) # same units as y
mae = mean_absolute_error(y_test, y_pred) # robust to outliers
r2 = r2_score(y_test, y_pred) # 1=perfect, 0=mean, <0=worse
mape = mean_absolute_percentage_error(y_test, y_pred) # % error
print(f"RMSE: {rmse:.3f}")
print(f"MAE: {mae:.3f}")
print(f"R2: {r2:.3f}")
print(f"MAPE: {mape:.1%}")
# Adjusted R2 accounts for number of features
n, p = X_test.shape
adj_r2 = 1 - (1 - r2) * (n - 1) / (n - p - 1)決定木回帰
木ベースの回帰器は区分一定の予測を行います — 学習データの範囲を超えて外挿できません。平均により分散を減らすのがランダムフォレストで、逐次修正によりバイアスを減らすのが勾配ブースティングです。平均ではなく分位点を予測するのが、分位点回帰(loss='quantile')です — 下側/上側の分位点モデルを組み合わせれば予測区間が得られ、不確実性の推定が必要なときに有用です。
from sklearn.tree import DecisionTreeRegressor
from sklearn.ensemble import RandomForestRegressor, GradientBoostingRegressor
# Single tree (piecewise constant predictions)
dt = DecisionTreeRegressor(max_depth=5, min_samples_leaf=10,
random_state=42)
dt.fit(X_train, y_train)
# Random forest regressor (averages trees)
rf = RandomForestRegressor(n_estimators=200, max_features="sqrt",
n_jobs=-1, random_state=42)
rf.fit(X_train, y_train)
# Gradient boosting regressor
gb = GradientBoostingRegressor(n_estimators=200, learning_rate=0.1,
max_depth=3, random_state=42)
gb.fit(X_train, y_train)
# Quantile regression — predict ranges instead of points
from sklearn.ensemble import GradientBoostingRegressor
gbr_lower = GradientBoostingRegressor(loss="quantile", alpha=0.1)
gbr_upper = GradientBoostingRegressor(loss="quantile", alpha=0.9)
gbr_lower.fit(X_train, y_train)
gbr_upper.fit(X_train, y_train)正則化パス
正則化パスが、alpha が増えるにつれ Lasso の係数がゼロへ縮む様子を示します — 異なるペナルティの強さの下での特徴の重要性の可視化です。高い alpha で生き残る特徴が最も予測的です。どの特徴が効くかの理解や、クロスバリデーションの前の合理的な alpha の範囲の選択のための、素晴らしい診断です。
import numpy as np
import matplotlib.pyplot as plt
from sklearn.linear_model import lasso_path
# Compute Lasso coefficients for many alpha values
alphas, coefs, _ = lasso_path(X_train_scaled, y_train,
alphas=np.logspace(-3, 1, 100))
# Plot: each line is a coefficient vs alpha
plt.figure(figsize=(8, 5))
for coef in coefs:
plt.plot(alphas, coef)
plt.xscale("log")
plt.xlabel("alpha (regularization strength)")
plt.ylabel("coefficient")
plt.title("Lasso regularization path")
plt.axhline(0, color="k", lw=0.5)
plt.show()残差分析
残差プロットがモデルの仕様誤りを診断します。0 の周りのランダムな雲がモデルの良好な適合を意味し、U 字型は欠けた非線形性を(多項式特徴の追加か木の使用)、漏斗型は不均一分散を(y の log 変換を試す)示唆します。残差の正規性が効くのは推論(信頼区間)のためであり、予測精度のためではありません。
import matplotlib.pyplot as plt
import seaborn as sns
residuals = y_test - y_pred
fig, axes = plt.subplots(1, 2, figsize=(12, 5))
# 1. Residuals vs predicted — should look random around 0
axes[0].scatter(y_pred, residuals, alpha=0.5)
axes[0].axhline(0, color="r", linestyle="--")
axes[0].set_xlabel("Predicted"); axes[0].set_ylabel("Residual")
# 2. Residual distribution — should be ~normal
sns.histplot(residuals, kde=True, ax=axes[1])
axes[1].set_xlabel("Residual")
plt.show()
# Patterns in residuals suggest model issues:
# - U-shape: missing non-linearity (add polynomial features)
# - Funnel: heteroscedasticity (try log-transforming y)
# - Skew: try transforming y or use a different loss分類
二値分類の基本
predict がハードなクラスラベルを返し(しきい値 0.5)、predict_proba が確率を返します — 通常こちらが有用です。デフォルトの 0.5 のしきい値はめったに最適ではありません:より高い recall を得るには(陽性を多く捉える、がんスクリーニングなど)下げ、より高い precision を得るには(誤警報を減らす、スパムフィルタなど)上げましょう。しきい値に依存せず、陽性が陰性より上にランクされる度合いを測るのが ROC-AUC です。
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import (confusion_matrix, classification_report,
roc_auc_score, precision_recall_curve)
clf = LogisticRegression(max_iter=1000)
clf.fit(X_train, y_train)
y_pred = clf.predict(X_test)
y_proba = clf.predict_proba(X_test)[:, 1] # P(class=1)
# Confusion matrix: TN FP / FN TP
cm = confusion_matrix(y_test, y_pred)
print(cm)
print(classification_report(y_test, y_pred))
# Adjust threshold (default 0.5) to trade precision for recall
y_pred_custom = (y_proba > 0.3).astype(int) # higher recall
# ROC-AUC: probability ranking quality (threshold-independent)
print("ROC-AUC:", roc_auc_score(y_test, y_proba))混同行列と派生指標
不均衡データでは accuracy が誤解を招きます — 99% が陰性の dataset は、すべての陰性を予測するだけで 99% の精度になります。precision と recall が precision-recall のトレードオフを明らかにします:precision が「予測された陽性のうち、何個が本物か?」に、recall が「実際の陽性のうち、何個を捉えたか?」に答えます。両者の調和平均が F1 です。クラスが等しく重み付けされるべきなら macro、頻度を反映すべきなら weighted を使います。
from sklearn.metrics import (confusion_matrix, precision_score,
recall_score, f1_score)
# Binary: confusion_matrix returns [[TN, FP], [FN, TP]]
tn, fp, fn, tp = confusion_matrix(y_test, y_pred).ravel()
accuracy = (tp + tn) / (tp + tn + fp + fn)
precision = tp / (tp + fp) # of predicted positives, how many correct
recall = tp / (tp + fn) # of actual positives, how many caught
f1 = 2 * precision * recall / (precision + recall) # harmonic mean
specificity = tn / (tn + fp) # true negative rate
# sklearn shortcuts
print("Precision:", precision_score(y_test, y_pred))
print("Recall: ", recall_score(y_test, y_pred))
print("F1: ", f1_score(y_test, y_pred))
# Multi-class: average='macro' (unweighted) or 'weighted' (by class size)
print("Macro F1:", f1_score(y_test, y_pred, average="macro"))ROC と PR 曲線
ROC 曲線が、しきい値をまたいで recall(TPR)を偽陽性率に対してプロットします。ランクの品質を要約するのが曲線下面積(AUC)です(0.5 = ランダム、1.0 = 完全)。不均衡データでは ROC より PR 曲線の方が情報豊かです — 陰性が支配的なとき、ROC は欺瞞的に良く見えることがあります。ROC では左上、PR では右上を目指しましょう。
from sklearn.metrics import (roc_curve, precision_recall_curve,
auc, RocCurveDisplay, PrecisionRecallDisplay)
import matplotlib.pyplot as plt
# ROC curve: TPR (recall) vs FPR at all thresholds
fpr, tpr, thresholds = roc_curve(y_test, y_proba)
roc_auc = auc(fpr, tpr)
# PR curve: precision vs recall (better for imbalanced data)
prec, rec, thresholds = precision_recall_curve(y_test, y_proba)
pr_auc = auc(rec, prec)
fig, axes = plt.subplots(1, 2, figsize=(12, 5))
RocCurveDisplay.from_predictions(y_test, y_proba, ax=axes[0])
PrecisionRecallDisplay.from_predictions(y_test, y_proba, ax=axes[1])
axes[0].set_title(f"ROC (AUC={roc_auc:.3f})")
axes[1].set_title(f"PR (AUC={pr_auc:.3f})")
plt.show()多クラス分類
クラス数が 2 より大きいとき、LogisticRegression は softmax を使います(multi_class='multinomial')。どのクラスをモデルが混同するかが、クラスごとの precision/recall で分かります。クラスごとの recall を見るには、混同行列を(真のクラスの)行ごとに正規化しましょう — 系統的に誤分類されるカテゴリの発見に有用です。偶然の一致を調整するのが Cohen の kappa で、予測確率の品質を測るのが log_loss です(低い方が良い)。
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import (cohen_kappa_score, log_loss,
classification_report, confusion_matrix, ConfusionMatrixDisplay)
# Multiclass: logistic regression uses softmax by default
clf = LogisticRegression(multi_class="multinomial", max_iter=1000)
clf.fit(X_train, y_train)
y_pred = clf.predict(X_test)
y_proba = clf.predict_proba(X_test)
# Per-class report
print(classification_report(y_test, y_pred))
# Confusion matrix (now NxN)
disp = ConfusionMatrixDisplay.from_predictions(
y_test, y_pred, display_labels=clf.classes_,
cmap="Blues", normalize="true") # normalize per true class
# Multiclass metrics
print("Cohen's kappa:", cohen_kappa_score(y_test, y_pred))
print("Log loss: ", log_loss(y_test, y_proba))確率のキャリブレーション
80% と予測したモデルは 80% の確度で正しいはずです — しかし多くの分類器(Random Forest、SVM、Naive Bayes)は、キャリブレーションされていないスコアを出力します。これを修正するのが CalibratedClassifierCV で、ホールドアウトしたセット上で、等張回帰かシグモイドを fit します。確率に基づいて行動する(リスクスコアリング、しきい値調整)ときはキャリブレーションが効きます — ハードなクラス予測しか使わないなら不要です。
from sklearn.calibration import CalibratedClassifierCV, calibration_curve
import matplotlib.pyplot as plt
# Many classifiers output poorly-calibrated probabilities
# (e.g. Random Forest, SVM). Calibrate them.
# Method 1: isotonic regression (more flexible, needs more data)
# Method 2: sigmoid (Platt scaling) — parametric, works with less data
calibrated = CalibratedClassifierCV(rf, method="isotonic", cv=5)
calibrated.fit(X_train, y_train)
y_proba = calibrated.predict_proba(X_test)[:, 1]
# Calibration curve: predicted prob vs observed frequency
prob_true, prob_pred = calibration_curve(y_test, y_proba, n_bins=10)
plt.plot([0, 1], [0, 1], "k--")
plt.plot(prob_pred, prob_true, "s-")
plt.xlabel("Predicted probability"); plt.ylabel("Observed frequency")
plt.show()クラスタリングの深掘り
k の選択:Elbow と Silhouette
ひじ法は、inertia の低下が急でなくなる k を探します — 主観的で、時に見えません。より原理的なのが silhouette スコアです:各点が自分のクラスタと最も近い別のクラスタのどれに似ているかを測ります(範囲 -1〜1)。Silhouette > 0.5 が合理的な構造で、> 0.7 が強いです。両方を可視化し、ひじが不明瞭なときは silhouette を優先しましょう。
from sklearn.cluster import KMeans
from sklearn.metrics import silhouette_score, silhouette_samples
import matplotlib.pyplot as plt
# Elbow method: inertia (sum of squared distances to centroid)
inertias = []
for k in range(1, 11):
km = KMeans(n_clusters=k, n_init=10, random_state=42).fit(X)
inertias.append(km.inertia_)
plt.plot(range(1, 11), inertias, "o-")
plt.xlabel("k"); plt.ylabel("Inertia"); plt.title("Elbow method")
plt.show()
# Silhouette: -1 (bad) to 1 (well-clustered), 0 = on boundary
silhouettes = []
for k in range(2, 11):
labels = KMeans(n_clusters=k, n_init=10, random_state=42).fit_predict(X)
silhouettes.append(silhouette_score(X, labels))Silhouette プロット
silhouette プロットが、クラスタごとにグループ化した、すべてのサンプルの silhouette 係数を示します。等幅の「ナイフ」形状がバランスの取れたクラスタを意味し、不均一な幅は、あるクラスタが支配的であることを意味します。赤い破線が平均で — この線を下回る平均のクラスタは分離が悪いです。異なる k の値を視覚的に比較するには、このプロットを使いましょう。
from sklearn.metrics import silhouette_samples
import matplotlib.pyplot as plt
import numpy as np
k = 4
km = KMeans(n_clusters=k, n_init=10, random_state=42).fit(X)
labels = km.labels_
sil_values = silhouette_samples(X, labels)
fig, ax = plt.subplots(figsize=(8, 6))
y_lower = 10
for i in range(k):
ith = np.sort(sil_values[labels == i])
y_upper = y_lower + len(ith)
ax.fill_betweenx(np.arange(y_lower, y_upper), 0, ith, alpha=0.7)
ax.text(-0.05, (y_lower + y_upper) / 2, str(i))
y_lower = y_upper + 10
ax.axvline(sil_values.mean(), color="red", linestyle="--")
ax.set_xlabel("Silhouette coefficient"); ax.set_ylabel("Cluster")
plt.show()HDBSCAN(Hierarchical DBSCAN)
HDBSCAN が、DBSCAN の最大の弱点 — eps の調整必要性 — を修正します。変化する密度レベルにわたり階層を構築し、安定したクラスタを取り出すため、クラスタの密度が変化するデータで機能します。主なパラメータが min_cluster_size で、直感的です(注目する最小のクラスタ)。まばらな領域のポイントがラベル -1(ノイズ)を得ます。実世界のデータでは、HDBSCAN が K-Means より意味のあるクラスタをしばしば作ります。
import hdbscan # pip install hdbscan
# HDBSCAN: DBSCAN that automatically chooses eps via hierarchy
clusterer = hdbscan.HDBSCAN(
min_cluster_size=5, # min points to form a cluster
min_samples=None, # how conservative to be about noise
metric="euclidean",
cluster_selection_method="eom", # 'leaf' for fine-grained
)
labels = clusterer.fit_predict(X)
# Soft clustering: probability of cluster membership
probs = clusterer.probabilities_
# Compare clusters across parameter settings
clusterer.condensed_tree_.plot()クラスタリングの評価
内部の指標(silhouette、Davies-Bouldin、Calinski-Harabasz)が、グラウンドトゥルースなしでクラスタの品質を評価します — モデル選択に有用です。既知のラベルとクラスタリングを比較するのが外部の指標(ARI、NMI)です — ラベル付きデータでのベンチマークに有用です。ARI と NMI のどちらも偶然を調整し、置換不変です。最良の単一指標はなく — いくつかを使い、クラスタを可視化しましょう。
from sklearn.metrics import (silhouette_score, davies_bouldin_score,
calinski_harabasz_score, adjusted_rand_score, normalized_mutual_info_score)
# Internal metrics (no ground truth)
print("Silhouette: ", silhouette_score(X, labels)) # higher = better
print("Davies-Bouldin: ", davies_bouldin_score(X, labels)) # lower = better
print("Calinski-Harabasz: ", calinski_harabasz_score(X, labels)) # higher = better
# External metrics (when you have ground-truth labels)
true_labels = y # e.g. the actual iris species
print("Adjusted Rand: ", adjusted_rand_score(true_labels, labels))
print("NMI: ", normalized_mutual_info_score(true_labels, labels))
# ARI and NMI: 0 = random, 1 = perfect match
# Both are invariant to label permutations (cluster 1 vs cluster 2 doesn't matter)クラスタリングのための次元削減
高次元でのクラスタリングは次元の呪いに苦しみます — 距離が無意味になります。まず 5〜50 次元へ削減しましょう(線形で速い PCA か、非線形で局所構造を保つ UMAP)。t-SNE は可視化専用です(新しいデータのための transform メソッドがなく、歪みのためクラスタリングの入力には不適切です)。クラスタの可視化は、t-SNE か UMAP で 2D に必ず行いましょう。
from sklearn.decomposition import PCA, UMAP # umap-learn package
from sklearn.manifold import TSNE
from sklearn.cluster import KMeans
# Reduce dimensions BEFORE clustering high-dim data
# PCA: linear, fast, preserves global structure
pca = PCA(n_components=10, random_state=42).fit(X)
X_pca = pca.transform(X)
# UMAP: non-linear, fast, preserves local+global structure
reducer = UMAP(n_components=5, random_state=42)
X_umap = reducer.fit_transform(X)
# t-SNE: visualization only (no transform on new data)
X_tsne = TSNE(n_components=2, perplexity=30, random_state=42).fit_transform(X)
# Cluster on the embeddings
labels = KMeans(n_clusters=4, n_init=10, random_state=42).fit_predict(X_umap)
# Plot 2D embedding colored by cluster
plt.scatter(X_tsne[:, 0], X_tsne[:, 1], c=labels, cmap="tab10", s=10)
plt.show()次元削減
PCA(主成分分析)
PCA が、最も多くの分散を捉える直交軸(主成分)を見つけ、ほとんどの情報を保ちつつ高次元データを圧縮させます。スケーリングが効きます — PCA は特徴のスケールに敏感です。95% の分散を自動的に保つのが n_components=0.95 です。PCA は線形で速いですが、分散 = 情報という仮定を置きます。これは常に真ではありません(低分散の特徴が識別的であることもあります)。
from sklearn.decomposition import PCA
# PCA finds orthogonal axes of maximum variance
pca = PCA(n_components=2, random_state=42)
X_pca = pca.fit_transform(X_scaled) # scaling matters!
# Explained variance: how much info each PC retains
print("Explained variance ratio:", pca.explained_variance_ratio_)
print("Total retained:", pca.explained_variance_ratio_.sum())
# Choose n_components to retain 95% of variance
pca_full = PCA(n_components=0.95, random_state=42).fit(X_scaled)
print("Components for 95%:", pca_full.n_components_)
X_reduced = pca_full.transform(X_scaled)
# Reconstruct (lossy) from compressed representation
X_reconstructed = pca_full.inverse_transform(X_reduced)可視化のための t-SNE
t-SNE が高次元データの 2D/3D 可視化に優れ、局所近傍を保つため、クラスタが視覚的に現れます。局所と大域の構造のバランスを制御するのが perplexity(通常 5〜50)です。t-SNE の歪み:クラスタのサイズとクラスタ間の距離は「意味を持ちません」。意味を持つのは局所近傍だけです。大きなデータでは遅いので、t-SNE の前に PCA で次元を削減しましょう(例えば 50 へ)。
from sklearn.manifold import TSNE
import matplotlib.pyplot as plt
# t-SNE is for 2D/3D visualization, NOT as preprocessing
tsne = TSNE(
n_components=2,
perplexity=30, # try 5-50; ~ sqrt(n_samples) is a heuristic
learning_rate="auto",
n_iter=1000,
init="pca", # better than random init
random_state=42,
)
X_tsne = tsne.fit_transform(X_scaled)
plt.scatter(X_tsne[:, 0], X_tsne[:, 1], c=y, cmap="tab10", s=10)
plt.colorbar(); plt.show()UMAP
UMAP が t-SNE のモダンな代替です:より速く、スケールが良く、局所と大域の構造の両方を保ち、決定的に重要なのは、新しいデータへの transform をサポートするため、パイプラインのステップになれることです。局所対大域のトレードオフを制御するのが n_neighbors で(小 = 局所の詳細、大 = 大域の構造)、ポイントがどれだけ密集するかの制御が min_dist です。ML パイプラインでは、2 ではなく 5〜50 次元への圧縮に UMAP を使いましょう。
from umap import UMAP # pip install umap-learn
# UMAP: faster than t-SNE, preserves more global structure,
# and supports transform on new data (good for ML pipelines)
reducer = UMAP(
n_components=2,
n_neighbors=15, # smaller = local, larger = global
min_dist=0.1, # how tightly points pack
metric="euclidean",
random_state=42,
)
X_umap = reducer.fit_transform(X_scaled)
# Can transform new data (unlike t-SNE)
X_new_umap = reducer.transform(X_new)
# Use in a pipeline as a preprocessor before clustering/classification
from sklearn.pipeline import Pipeline
pipe = Pipeline([
("umap", UMAP(n_components=5, random_state=42)),
("clf", RandomForestClassifier(random_state=42)),
])LDA(線形判別分析)
PCA(教師なし)と違い、LDA はクラスラベルを使い、クラス間分散を最大化しつつクラス内分散を最小化する射影を見つけます。n_components の最大は n_classes - 1 であるため、クラス数の少ない問題でしか有用ではありません。LDA は線形分類器も兼ねます(共通の共分散を持つガウスのクラスを仮定します)。ラベルがあり、クラス分離性を最大化する次元削減が欲しいときに LDA を使いましょう。
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
# LDA is SUPERVISED dimensionality reduction — uses class labels
# to find axes that best separate classes
lda = LinearDiscriminantAnalysis(n_components=2)
X_lda = lda.fit_transform(X_train, y_train) # note: y_train passed in
# Also a classifier (Gaussian model per class)
y_pred = lda.predict(X_test)
# Max n_components = n_classes - 1
# For 3 classes, you get at most 2 LDA components
# Compare: PCA ignores class labels (unsupervised);
# LDA uses labels to maximize class separabilityTruncated SVD(疎データ向け)
TruncatedSVD(テキストでは LSA とも)が、疎データ向けの PCA の代替です。データを中心化しないため、TF-IDF のような疎行列で機能します。TF-IDF と組み合わせると「トピック」が作れます — 共起する単語のグループです。より良いトピックモデルには、NMF かモダンな埋め込みベースのアプローチを試しましょう。テキストには約 100〜300 成分を保ち、正しい数はコーパスのサイズと下流のタスクに依存します。
from sklearn.decomposition import TruncatedSVD
# PCA doesn't work on sparse matrices (it needs to center data)
# Use TruncatedSVD instead — works directly on sparse TF-IDF, etc.
from scipy.sparse import csr_matrix
X_sparse = csr_matrix(X_tfidf) # e.g. from TfidfVectorizer
svd = TruncatedSVD(n_components=100, random_state=42)
X_reduced = svd.fit_transform(X_sparse)
# Often combined with TF-IDF for LSA (Latent Semantic Analysis)
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.decomposition import TruncatedSVD
vectorizer = TfidfVectorizer(max_features=10000)
lsa = Pipeline([
("tfidf", vectorizer),
("svd", TruncatedSVD(n_components=100, random_state=42)),
])
X_topics = lsa.fit_transform(documents)モデル評価
クロスバリデーション
クロスバリデーションが、複数の train/test 分割の平均により、堅牢な性能推定を与えます。分類でのクラスバランスの保持(不均衡データには不可欠)は StratifiedKFold です。異なる分割で CV を複数回実行するのが RepeatedStratifiedKFold です — より高い計算コストでより安定した推定です。モデル選択には、単一の train/test 分割ではなく必ず CV を使いましょう。
from sklearn.model_selection import (cross_val_score, cross_validate,
StratifiedKFold, KFold, RepeatedStratifiedKFold)
# Basic 5-fold CV
scores = cross_val_score(model, X, y, cv=5, scoring="accuracy")
print(f"{scores.mean():.3f} +/- {scores.std():.3f}")
# Stratified (preserves class balance — use for classification)
cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
scores = cross_val_score(model, X, y, cv=cv, scoring="f1_macro")
# Multiple metrics at once
results = cross_validate(model, X, y, cv=cv,
scoring=["accuracy", "f1_macro", "roc_auc_ovr"],
return_train_score=True)
print(results["test_f1_macro"].mean())
# Repeated CV for more stable estimates
rcv = RepeatedStratifiedKFold(n_splits=5, n_repeats=3, random_state=42)学習曲線
学習曲線が、dataset のサイズに対する学習と検証の性能をプロットします — バイアス対分散の最良の診断です。高い学習スコアと低い検証スコアの間の大きなギャップが過剰適合を意味し(データを増やす、正則化する、単純化する)、両スコアが低く近ければ学習不足です(より複雑なモデルか特徴の追加)。曲線が右端でまだ改善しているなら、より多くのデータが役立ちます。
from sklearn.model_selection import learning_curve
import matplotlib.pyplot as plt
train_sizes, train_scores, val_scores = learning_curve(
model, X, y,
train_sizes=np.linspace(0.1, 1.0, 10),
cv=5, scoring="accuracy", n_jobs=-1, random_state=42,
)
train_mean = train_scores.mean(axis=1)
val_mean = val_scores.mean(axis=1)
plt.plot(train_sizes, train_mean, "o-", label="Train")
plt.plot(train_sizes, val_mean, "o-", label="Validation")
plt.xlabel("Training samples"); plt.ylabel("Accuracy")
plt.legend(); plt.show()
# Diagnose:
# - High train, low val -> overfitting (high variance) -> more data or regularize
# - Both low and close -> underfitting (high bias) -> more complex model/features
# - Gap closing with data -> more data helps検証曲線(ハイパーパラメータ)
検証曲線が、単一のハイパーパラメータの値に対する性能をプロットします — モデルの挙動の理解と、grid search の前の合理的な範囲の発見に有用です。モデルの複雑さと共に学習スコアが上昇し続けるのに対し、検証スコアはピークを経て低下します。ピークが甘味点で、手前が学習不足、後が過剰適合です。
from sklearn.model_selection import validation_curve
import matplotlib.pyplot as plt
param_range = [1, 2, 4, 8, 16, 32, 64]
train_scores, val_scores = validation_curve(
RandomForestClassifier(random_state=42),
X, y,
param_name="max_depth",
param_range=param_range,
cv=5, scoring="accuracy", n_jobs=-1,
)
plt.plot(param_range, train_scores.mean(axis=1), "o-", label="Train")
plt.plot(param_range, val_scores.mean(axis=1), "o-", label="Validation")
plt.xlabel("max_depth"); plt.ylabel("Accuracy")
plt.legend(); plt.show()
# Sweet spot is where validation peaks before overfitting分類レポートの読み方
classification_report の macro 平均はすべてのクラスを等しく扱います(まれなクラスが効くときに良い)。クラスの頻度を反映するのが weighted 平均です(多数派の性能が支配するときに良い)。平均化の戦略は、各クラスを見逃すビジネスコストに基づき選びましょう。深刻な不均衡では、PR-AUC とクラスごとの recall を補いに使いましょう — 精度や F1 ですら、多数派を予測するだけのモデルを隠せます。
from sklearn.metrics import classification_report
report = classification_report(y_test, y_pred, output_dict=True)
# Per-class metrics + macro/weighted averages
import pandas as pd
df_report = pd.DataFrame(report).T
print(df_report[["precision", "recall", "f1-score", "support"]])
# 'macro' avg = unweighted mean across classes (treats all equally)
# 'weighted' avg = support-weighted mean (reflects class imbalance)
# Focus on:
# - macro F1 if all classes matter equally (e.g. digit recognition)
# - weighted F1 if rare classes matter less
# - recall of the positive class if it's the costly one (fraud, disease)
# For imbalanced classification, also report:
# - Precision-Recall AUC
# - Brier score (probability calibration)回帰指標の深掘り
回帰の指標はビジネスコストに基づき選びましょう。大きな誤差が不釣り合いに悪いなら RMSE(二乗のペナルティ)、同じ大きさのすべての誤差が等しく悪いなら MAE です。R2 は無次元で、dataset をまたいで比較できます。最悪のケースを示すのが max error です。カスタムの非対称な損失(例:過小予測をより罰する)が現実のコストに合います — 欠品のコストと過剰在庫のコストは違います。
from sklearn.metrics import (mean_squared_error, mean_absolute_error,
r2_score, explained_variance_score, max_error)
# RMSE — penalizes large errors; same units as y
rmse = mean_squared_error(y_test, y_pred, squared=False)
# MAE — robust to outliers; same units as y
mae = mean_absolute_error(y_test, y_pred)
# R^2 — fraction of variance explained (1.0 = perfect, 0 = predict mean)
r2 = r2_score(y_test, y_pred)
# Explained variance — like R^2 but ignores mean offset
evs = explained_variance_score(y_test, y_pred)
# Max error — single largest absolute error (worst-case)
max_err = max_error(y_test, y_pred)
# Custom asymmetric loss: penalize under-prediction more
def asymmetric_error(y_true, y_pred, under_penalty=2.0):
error = y_true - y_pred
return np.where(error > 0, under_penalty * error**2, error**2).mean()クロスバリデーションの戦略
K 分割のバリアント
正しい CV 戦略の選択は決定的に重要です。デフォルトが KFold です。分類には StratifiedKFold(クラスバランスを保持)。サンプルが相関しているとき(ユーザー/患者ごとに複数行)には GroupKFold — train と val の間での情報漏れを防ぎます。時系列データには TimeSeriesSplit(常に過去で学習し未来で検証)。間違った CV 戦略が、過剰に楽観的な推定を与えます。
from sklearn.model_selection import (KFold, StratifiedKFold,
GroupKFold, TimeSeriesSplit, RepeatedKFold)
# Standard K-fold (regression or balanced classification)
kf = KFold(n_splits=5, shuffle=True, random_state=42)
# Stratified (classification — preserves class proportions)
skf = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
# Group K-fold (when samples are not independent — e.g. multiple rows per patient)
gkf = GroupKFold(n_splits=5) # pass groups=patient_ids to CV
# Time series split (no shuffle — preserves temporal order)
tscv = TimeSeriesSplit(n_splits=5)
# Use with cross_val_score:
scores = cross_val_score(model, X, y, cv=gkf, groups=groups, scoring="f1")時系列クロスバリデーション
TimeSeriesSplit が時間順序を尊重します:各分割が過去で学習し未来で検証し、決して逆になりません。これが現実の予測に一致し、漏れを防ぎます。近くのサンプルが自己相関しているとき(明日の価格が今日の価格と相関するなど)には、gap パラメータを使いましょう。時系列データ上でのシャッフルした標準の KFold が、極めて楽観的な推定を与えます — よくある初心者の過ちです。
from sklearn.model_selection import TimeSeriesSplit
import matplotlib.pyplot as plt
import numpy as np
tscv = TimeSeriesSplit(n_splits=5, test_size=100)
# gap parameter (sklearn 1.0+): prevent leakage from train to test
tscv = TimeSeriesSplit(n_splits=5, test_size=100, gap=10)
for fold, (train_idx, test_idx) in enumerate(tscv.split(X)):
X_tr, X_te = X[train_idx], X[test_idx]
y_tr, y_te = y[train_idx], y[test_idx]
model.fit(X_tr, y_tr)
score = model.score(X_te, y_te)
print(f"Fold {fold}: train={len(train_idx)}, test={len(test_idx)}, score={score:.3f}")
# NEVER shuffle time-series data for CV — that leaks future into past
# Use gap to avoid leakage from autocorrelated near-future pointsグループを考慮した CV
データにグループがあるとき(患者、ユーザー、セッションごとに複数サンプル)、標準のランダム分割が情報を漏らします — モデルが train と test で同じエンティティを見るため、スコアが膨らみます。すべてのグループを完全に 1 分割の中に留めるのが GroupKFold です。典型的なシナリオ:医療データ(患者ごとに複数スキャン)、推薦(ユーザーごとに複数評価)、画像データ(シーンごとに複数フレーム)。グループを考慮した CV を使わないことが、ML で最もよくあるサイレントなバグの一つです。
from sklearn.model_selection import GroupKFold, GroupShuffleSplit
# When the same entity appears in multiple rows (e.g. multiple X-rays per patient),
# random splits leak: the model memorizes patient-specific features
# instead of learning generalizable patterns.
# Solution: keep all rows of a group in the same split
gkf = GroupKFold(n_splits=5)
scores = cross_val_score(model, X, y, cv=gkf, groups=df["patient_id"])
# GroupShuffleSplit: random train/test split respecting groups
gss = GroupShuffleSplit(n_splits=5, test_size=0.2, random_state=42)
for train_idx, test_idx in gss.split(X, groups=df["patient_id"]):
...
# Always pass the groups argument to CV functions
# Common scenarios: patients, users, sessions, image batchesネストした CV(偏りのないハイパーパラメータ調整)
標準の GridSearchCV が報告する CV スコアは楽観的です — スコア付けに使ったのと同じ分割で最良のハイパーパラメータを選んでいるからです。これを修正するのがネストした CV です:外側の CV ループが、真にホールドアウトした分割上で、チューニング手順全体を評価します。結果が、(チューニングを含む)モデルリングパイプライン全体が新しいデータでどう性能を出すかの、偏りのない推定です。誠実なベンチマークに、特にモデルを比較するときに使いましょう。
from sklearn.model_selection import (GridSearchCV, cross_val_score,
StratifiedKFold)
# Outer loop: estimate generalization performance
# Inner loop: tune hyperparameters
# Without nesting, GridSearchCV's CV score is optimistic (it selected the best
# hyperparameters using the same data)
inner_cv = StratifiedKFold(n_splits=3, shuffle=True, random_state=42)
outer_cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
grid = GridSearchCV(
RandomForestClassifier(random_state=42),
param_grid={"max_depth": [3, 5, 10], "n_estimators": [50, 100]},
cv=inner_cv, scoring="f1", n_jobs=-1,
)
nested_scores = cross_val_score(grid, X, y, cv=outer_cv, scoring="f1")
print(f"Nested CV F1: {nested_scores.mean():.3f} +/- {nested_scores.std():.3f}")
# Fit the final model on all data
grid.fit(X, y)
best_model = grid.best_estimator_前処理付きの CV(Pipeline)
前処理は学習分割上でのみ fit されなければなりません — さもないと、テスト分割の統計(平均、中央値、スケーリング係数)が学習へ漏れ、楽観的な CV スコアになります。修正はすべてを Pipeline で包むことです:scikit-learn が、各 CV 分割が学習部分で自分の前処理を fit することを保証します。これが、誠実な ML 評価のための最重要のベストプラクティスです。CV の前に全 dataset で前処理を fit してはいけません。
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import cross_val_score
from sklearn.impute import SimpleImputer
# RIGHT: wrap preprocessing in a Pipeline so each fold fits
# its own scaler/imputer on the training portion only
pipe = Pipeline([
("impute", SimpleImputer(strategy="median")),
("scale", StandardScaler()),
("model", RandomForestClassifier(random_state=42)),
])
scores = cross_val_score(pipe, X, y, cv=5, scoring="f1")
# WRONG: fit scaler on the whole dataset, then CV
# (leaks test-fold statistics into training)
# scaler.fit(X) # NO - includes future test folds
# X_scaled = scaler.transform(X)
# cross_val_score(model, X_scaled, y, cv=5) # optimistic scores
# Pipelines also make deployment easier (one object, no leakage)ハイパーパラメータ調整
Grid Search
GridSearchCV がすべての組み合わせを網羅的に評価します — 徹底的ですが高コストです(組合せ爆発)。小さくうまく選ばれたパラメータグリッドがあるときに使いましょう。適切な scoring 指標は必ず渡しましょう(デフォルトは accuracy で、不均衡な分類では誤りです)。返される推定器が使える状態になるよう、全学習データ上で最良のモデルを再学習するのが refit=True です。
from sklearn.model_selection import GridSearchCV
# Exhaustive search over all combinations
param_grid = {
"n_estimators": [50, 100, 200],
"max_depth": [3, 5, 10, None],
"min_samples_leaf": [1, 5, 10],
}
# 3 * 4 * 3 = 36 combinations, * 5 folds = 180 fits
grid = GridSearchCV(
RandomForestClassifier(random_state=42),
param_grid=param_grid,
cv=5,
scoring="f1",
n_jobs=-1,
refit=True, # refit best model on full data
return_train_score=True,
)
grid.fit(X_train, y_train)
print("Best params: ", grid.best_params_)
print("Best CV F1: ", grid.best_score_)
best_model = grid.best_estimator_Randomized Search
RandomizedSearchCV が分布から n_iter の組み合わせをサンプリングします — 多くのパラメータが効くとき、grid search よりはるかに効率的です。学習率と正則化の強さには loguniform を使いましょう(桁が大きく変わるため)。50〜100 イテレーションが通常、ほぼ最適な構成を見つけます。ランダム性が、grid search が見逃すかもしれない局所最適からの脱出にも役立ちます。
from sklearn.model_selection import RandomizedSearchCV
from scipy.stats import randint, loguniform
# Sample from distributions instead of enumerating all combos
# Much more efficient when the grid is large
param_dist = {
"n_estimators": randint(50, 500), # discrete uniform
"max_depth": [3, 5, 10, None],
"min_samples_leaf": randint(1, 20),
"learning_rate": loguniform(1e-3, 1e0), # log-uniform
}
rand_search = RandomizedSearchCV(
GradientBoostingClassifier(random_state=42),
param_distributions=param_dist,
n_iter=50, # number of parameter settings sampled
cv=5,
scoring="f1",
n_jobs=-1,
random_state=42,
)
rand_search.fit(X_train, y_train)
print("Best params:", rand_search.best_params_)ベイズ最適化(Optuna)
Optuna がベイズ最適化を使い、前の試行の結果に基づき次のハイパーパラメータを知的にサンプリングします — grid/ランダム検索よりはるかにサンプル効率が高いです。剪定(悪い試行の早期停止)、条件付きのパラメータ空間、多目的最適化もサポートします。study オブジェクトがすべての試行を保存するため、パラメータの重要性和最適化履歴を可視化できます。多くのハイパーパラメータを持つ高コストなモデルに最適です。
import optuna
def objective(trial):
# Suggest hyperparameters
n_estimators = trial.suggest_int("n_estimators", 50, 500)
max_depth = trial.suggest_int("max_depth", 3, 20)
lr = trial.suggest_float("learning_rate", 1e-3, 1e0, log=True)
min_samples = trial.suggest_int("min_samples_leaf", 1, 20)
model = GradientBoostingClassifier(
n_estimators=n_estimators, max_depth=max_depth,
learning_rate=lr, min_samples_leaf=min_samples,
random_state=42,
)
# 5-fold CV F1
score = cross_val_score(model, X_train, y_train, cv=5,
scoring="f1", n_jobs=-1).mean()
return score # Optuna maximizes by default
study = optuna.create_study(direction="maximize")
study.optimize(objective, n_trials=100, timeout=600)
print("Best trial:", study.best_trial.params)
print("Best F1: ", study.best_trial.value)Halving Search(逐次半減)
halving search が反復的なリソース配分の戦略です:少ないデータで多くの候補を評価し、最悪を取り除き、生存者をより多くのデータ(または推定器)で再評価します。完全な grid search よりはるかに速く、しばしば似た解を見つけます。さらに大きな空間には HalvingRandomSearchCV を使いましょう。候補をどれほど積極的に取り除くかは 'factor' が制御します。多くのハイパーパラメータと限られた時間があるときの、素晴らしいデフォルトです。
from sklearn.experimental import enable_halving_search_cv # noqa
from sklearn.model_selection import HalvingGridSearchCV, HalvingRandomSearchCV
# Allocate more resources to promising candidates iteratively
halving = HalvingGridSearchCV(
RandomForestClassifier(random_state=42),
param_grid={"max_depth": [3, 5, 10, None],
"n_estimators": [50, 100, 200]},
cv=5,
scoring="f1",
factor=3, # eliminate bottom 2/3 each round
aggressive_elimination=False,
n_jobs=-1,
)
halving.fit(X_train, y_train)
print("Best params:", halving.best_params_)
print("Best score: ", halving.best_score_)
# Much faster than full GridSearchCV — evaluates many candidates
# cheaply first, then invests more resources in the promising ones.チューニングのベストプラクティス
最大のチューニングの罪:テストセットでの最適化、検証セットへの過剰適合までのチューニング、最終性能としての CV スコアの報告です。学習データ上の CV 経由でチューニングし、その後、きれいなホールドアウトのテストセット上で最終モデルを 1 回評価しましょう。選んだハイパーパラメータが頑健である(分割をまたぐ小さな std)こと、幸運なランダムシードではないことを確認するため、cv_results_ 全体を検査しましょう。大まかに始めて絞り込む — ほとんどの利得は少数の重要なパラメータから来ます。