🔖 キーワード索引

本ページは 機械学習ライブラリ（ML Library）を 12 のセクションで多角的に解説します。 上のチップは検索・関連語の手がかりです。 以下のリンクで各セクションに直接ジャンプできます：

🎨 直感で掴む

機械学習ライブラリは「線形回帰・決定木・ニューラルネットなどの定型処理を、 数行のコードで呼び出せる関数集」。 NumPy / SciPy で行列演算や最適化を 1 つずつ手書きしていた時代に対し、 scikit-learn は LinearRegression().fit(X, y) の 1 行で「正規方程式 → 逆行列計算 → 残差検定」までを完結する。

主要 5 ライブラリは scikit-learn（表データ・伝統的 ML の事実上標準）、 LightGBM / XGBoost（勾配ブースティング、 Kaggle 表データ優勝多数）、 PyTorch（深層学習の研究標準）、 TensorFlow / Keras（モバイル・本番デプロイ）、 Hugging Face transformers（事前学習モデル呼出）。 SSDSE のような 47 行 × 110 列の表データは scikit-learn + LightGBM が最適、 画像・自然言語は PyTorch、 と棲み分ける。

🎨 直感で掴む — 具体例で理解する

ML ライブラリを使うと「線形回帰を書くのに数行」「CNN を 30 行で組む」が実現する。 これらが無かった時代は NumPy で行列演算を直接書き、 微分も手計算していた。 学術と産業の標準が揃ったからこそ、 AI は急速に普及した。 ライブラリの選定は「用途 + チーム習熟度 + 推論環境」で決める。 例：研究は PyTorch、 産業は TF Lite、 表データは LightGBM、 と棲み分ける。

🎨 ライブラリ選定の決定木

どのライブラリを使うべきか、 状況別の指針：

🗓 ML ライブラリ 歴史年表（2007-2024）

🎨 「最初に学ぶべき 5 ライブラリ」フローチャート

初学者が 「これだけは押さえる」 5 つのライブラリと習得順序：

1. ① NumPy：すべての数値計算の基礎。 ndarray を自在に操れること。
2. ② pandas：表データ操作の事実上標準。 read_csv / groupby / merge を体に叩き込む。
3. ③ matplotlib + seaborn：可視化。 EDA で必須。
4. ④ scikit-learn：古典 ML の統一インタフェース。 fit/predict の習慣化。
5. ⑤ PyTorch or LightGBM：DL ／勾配ブースティングのうち、 やりたいタスクに合わせ片方を深く。

💡 この 5 つで kaggle 銅メダル / SSDSE データコンペ予選通過レベル に十分到達できます。 焦って全部を触ろうとせず、 1 つずつ深堀りするのが上達の近道。

📐 定義

scikit-learn、 TensorFlow、 PyTorch等

英語名 ML Library。

📐 数式・定義

機械学習ライブラリを数式 / 形式定義で表す：

ライブラリの `fit` メソッドは、 損失関数の最適化問題を内部で解いている。 高水準 API がこの数式を 1 行に隠蔽する。

🔬 数式を言葉で読み解く

上の数式に出てきた記号を 1 つずつ解説します。 数式が出てくる試験問題（統計検定・G 検定・基本情報）では、 各記号の意味を答えられるかが分岐点：

🔬 数式を言葉で読み解く（拡張版・ライブラリ選定の数理）

ML ライブラリ選定は単なる流行ではなく、 (1) 開発生産性（API 統一） (2) 計算性能（GPU/分散） (3) エコシステム（依存ライブラリ・モデル動物園） (4) 保守可能性（ライセンス・コミュニティ） の 4 軸で評価します。 本ページでは、 これらを定量化する数式と SSDSE-B-2026 を用いた実ベンチを紹介します。

📐 ライブラリ選定の中核 4 指標

📊 主要 ML ライブラリ比較表

🧮 SSDSE-B 実値計算 — 都道府県データで手を動かす

SSDSE-B-2026 から 「総人口 → 出生数」を予測する 4 ライブラリ比較。 sklearn・XGBoost・LightGBM・PyTorch の R² を並べる典型ベンチ。

使用データ：SSDSE-B-2026.csv（独立行政法人 統計センター提供、 47 都道府県 × 100 超の社会経済指標）。 出典

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

import pandas as pd
from sklearn.linear_model import LinearRegression
from sklearn.ensemble import GradientBoostingRegressor
from sklearn.metrics import r2_score

df = pd.read_csv('data/raw/SSDSE-B-2026.csv', encoding='cp932', skiprows=[1])
df = df.rename(columns={df.columns[2]: 'pref'})

X = df[['A1101']].values
y = df['A4101'].values

# sklearn ファミリーで 2 種比較
models = {
    'sklearn LinearReg':   LinearRegression(),
    'sklearn GBR':         GradientBoostingRegressor(n_estimators=200, random_state=42),
}
for name, m in models.items():
    m.fit(X, y)
    print(f'{name:25s} R² = {r2_score(y, m.predict(X)):.4f}')

# 同じ X, y を XGBoost / LightGBM / PyTorch に渡す形でも対応可能

💬 総人口 1 列から出生数を当てると、線形回帰で R² = 0.9723、勾配ブースティングで 0.9965 になった。どちらも学習に使った 564 行（47 県 × 12 年度）で測った当てはまりで、200 本の木を持つ GBR は同じ県の 12 年度分をほぼ覚えられるので、この 0.024 の差を汎化性能の差とは読めない。ライブラリを比べるなら、県単位で分けた交差検証で測り直す。

▲ 上記コードはそのまま実行可能。 CP932 エンコーディング・skiprows=[1]（2 行目の日本語見出し行をスキップし、 1 行目の英語コード行をヘッダにする）・列名の英数字コード（A1101 = 総人口 など）に注意。

🧮 SSDSE-B-2026 実値ベンチ ①：sklearn vs XGBoost vs LightGBM の精度・速度比較

47 都道府県の 高齢化階層（低/中/高） を、 人口・出生・就業データから予測する分類タスクで、 3 ライブラリの精度と学習時間を比較します。

🐍 Python 実装（コード ①）

🎯 このコードでやること：同じ訓練データに対して RandomForest / XGBoost / LightGBM を順番に学習させ、 学習時間と検証精度を比較。

📥 入力データ:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

import pandas as pd, time
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
import xgboost as xgb
import lightgbm as lgb

df = pd.read_csv('data/raw/SSDSE-B-2026.csv', encoding='cp932', skiprows=[1])
latest = df[df['SSDSE-B-2026'] == 2023].reset_index(drop=True)   # 2023 年度の 47 都道府県
latest['aging'] = latest['A1303'] / latest['A1101']
y = pd.qcut(latest['aging'], 3, labels=[0, 1, 2]).astype(int)

features = ['A1101', 'A4101', 'A4103', 'B4101', 'B4102', 'C3301', 'C5401', 'F3101']
X = latest[features].fillna(0)
Xtr, Xte, ytr, yte = train_test_split(X, y, test_size=0.3, random_state=42, stratify=y)

results = {}
for name, model in [
    ('sklearn-RF', RandomForestClassifier(n_estimators=100, random_state=42)),
    ('XGBoost',    xgb.XGBClassifier(n_estimators=100, random_state=42, use_label_encoder=False, eval_metric='mlogloss')),
    ('LightGBM',   lgb.LGBMClassifier(n_estimators=100, random_state=42, verbose=-1)),
]:
    t0 = time.time()
    model.fit(Xtr, ytr)
    dt = time.time() - t0
    acc = accuracy_score(yte, model.predict(Xte))
    results[name] = (dt, acc)
    print(f'{name}: 時間={dt:.3f}s, accuracy={acc:.3f}')

📤 実行例（実測）:

💬 結果の読み方：3 クラス（高齢化率の三分位）でテストは 15 県しかなく、 当てずっぽうでも 0.333 になる。 sklearn-RF は 0.733（15 県中 11 県正解）、 XGBoost は 0.800（12 県正解）と当てずっぽうを大きく上回る一方、 LightGBM は 0.333（5 県正解）で何も学べていない。 LightGBM は葉 1 枚に最低 20 件（min_child_samples の既定値）を求めるので、 学習用 32 県では 1 回も分割できず、 全県に同じクラスを返しているためである。 小標本では「ライブラリの性能差」より「既定のハイパーパラメータがデータ量に合っているか」で結果が決まる。 速度は XGBoost が 0.25 秒と最も遅く、 RF と LightGBM は 0.02〜0.03 秒（時間は環境で数倍変わる）。

🧮 SSDSE-B-2026 実値ベンチ ②：PyTorch でニューラルネットワークと比較

同じデータに PyTorch で MLP を学習させ、 古典 ML と DL のトレードオフを比較します。 小規模 (n=47) では DL は過学習しやすい ことを実値で確認できます。

🐍 Python 実装（コード ②）

🎯 このコードでやること：PyTorch で 2 層 MLP を構築し、 100 エポック学習。 sklearn と精度・時間を比較。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

import torch
import torch.nn as nn
from sklearn.preprocessing import StandardScaler

torch.manual_seed(0)   # 初期重みの種を固定して毎回同じ結果にする
sc = StandardScaler()
Xtr_s = torch.tensor(sc.fit_transform(Xtr), dtype=torch.float32)
Xte_s = torch.tensor(sc.transform(Xte), dtype=torch.float32)
ytr_t = torch.tensor(ytr.values, dtype=torch.long)
yte_t = torch.tensor(yte.values, dtype=torch.long)

model = nn.Sequential(
    nn.Linear(8, 16), nn.ReLU(),
    nn.Linear(16, 3),
)
opt = torch.optim.Adam(model.parameters(), lr=1e-2)
loss_fn = nn.CrossEntropyLoss()

t0 = time.time()
for epoch in range(100):
    opt.zero_grad()
    loss = loss_fn(model(Xtr_s), ytr_t)
    loss.backward()
    opt.step()
dt = time.time() - t0

with torch.no_grad():
    pred = model(Xte_s).argmax(1)
    acc = (pred == yte_t).float().mean().item()
print(f'PyTorch MLP: 時間={dt:.3f}s, accuracy={acc:.3f}')

📤 実行例:

💬 結果の読み方：accuracy 0.600（15 県中 9 県正解）は、 当てずっぽう（0.333）は上回るものの、 直前の sklearn-RF 0.733・XGBoost 0.800 には届かない。 8 特徴量を 16 ユニットの中間層で受ける MLP は、 学習用 32 県に対してパラメータが 195 個と多く、 100 エポックの全件学習では過学習と学習不足のどちらにも転びうる。 DL は数千〜数百万サンプルから真価を発揮する。 なお torch.manual_seed(0) を入れないと初期重みが毎回変わり、 正解率も実行ごとに変わる（種を固定しない比較は結論にならない）。

🧮 SSDSE-B-2026 実値ベンチ ③：sklearn パイプライン構築（best practice）

sklearn の Pipeline と ColumnTransformer を用いて、 前処理 → モデル学習 → 評価 を 1 オブジェクトで管理する正攻法を実装します。 これは 本番運用に直結する書き方 です。

🐍 Python 実装（コード ③）

🎯 このコードでやること：数値変数を標準化、 カテゴリ変数を One-Hot 化し、 LightGBM で予測するパイプラインを構築。 cross_val_score で交差検証。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

from sklearn.pipeline import Pipeline
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.model_selection import cross_val_score
import lightgbm as lgb

num_cols = ['A1101', 'A4101', 'A4103', 'B4101']
preproc = ColumnTransformer([
    ('num', StandardScaler(), num_cols),
])
pipe = Pipeline([
    ('pre', preproc),
    ('clf', lgb.LGBMClassifier(n_estimators=100, verbose=-1, random_state=0, n_jobs=1)),
])
scores = cross_val_score(pipe, latest[num_cols], y, cv=5)
print(f'5-fold CV accuracy: {scores.mean():.3f} ± {scores.std():.3f}')

📤 実行例:

💬 結果の読み方：5 分割交差検証で 0.320 ± 0.016。 3 クラス分類の当てずっぽうが 0.333 なので、 このモデルはまったく学習できていない（標準偏差 0.016 が小さいのは「安定して当てずっぽう」という意味であって、 良いモデルの証拠ではない）。 各分割の学習データは 37〜38 県で、 LightGBM の既定 min_child_samples=20 では葉を 2 つに分けられず、 どの分割でも 1 クラスを返すだけになる。 標準化の Pipeline は正しく組めていても、 モデル側の既定値がデータ量に合わなければ結果は出ない。 Pipeline は前処理リーク防止にも効くので、 包む習慣自体は重要。

🧮 SSDSE-B-2026 実値ベンチ ④：sklearn 回帰モデル 5 種一括比較

「都道府県の総人口 (A1101) を 出生数(A4101)・合計特殊出生率(A4103)・年平均気温(B4101) から予測する」回帰タスクで、 sklearn の 5 種類の回帰モデルを一括比較します。 R² と RMSE で精度を、 学習時間で速度を評価します。

🐍 Python 実装（コード ④）

🎯 このコードでやること：LinearRegression / Ridge / Lasso / RandomForestRegressor / GradientBoostingRegressor の 5 種を交差検証で評価する。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

import pandas as pd, time
from sklearn.linear_model import LinearRegression, Ridge, Lasso
from sklearn.ensemble import RandomForestRegressor, GradientBoostingRegressor
from sklearn.model_selection import cross_val_score
import numpy as np

df = pd.read_csv('data/raw/SSDSE-B-2026.csv', encoding='cp932', skiprows=[1])
latest = df[df['SSDSE-B-2026'] == 2023].reset_index(drop=True)   # 2023 年度の 47 都道府県
X = latest[['A4101', 'A4103', 'B4101']].fillna(0)
y = latest['A1101']

models = {
    'LinearReg': LinearRegression(),
    'Ridge': Ridge(alpha=1.0),
    'Lasso': Lasso(alpha=100.0),
    'RandomForest': RandomForestRegressor(n_estimators=100, random_state=42),
    'GBR': GradientBoostingRegressor(n_estimators=100, random_state=42),
}

for name, mdl in models.items():
    t0 = time.time()
    r2 = cross_val_score(mdl, X, y, cv=5, scoring='r2').mean()
    dt = time.time() - t0
    print(f'{name}: R²={r2:.3f}, t={dt:.3f}s')

📤 実行例:

💬 結果の読み方：総人口 ≈ 出生数などの 線形関係が強いため、 線形回帰系（3 つとも R²=0.982）が RandomForest（0.891）・GBR（0.900）を上回る。 Ridge(alpha=1)・Lasso(alpha=100) も小数 3 桁まで線形回帰と同じで、 標準化していない特徴量に対してこの程度の alpha をかけても予測はほとんど変わらない。 木系は学習データの範囲の外へ外挿できないので、 東京都がテスト側に回った分割で R² を落とす。 「複雑モデル＝必ず良い」ではない ことの典型例。 ライブラリ選定はタスクの性質次第。

🧮 SSDSE-B-2026 実値ベンチ ⑤：モデル保存 / 読込（joblib vs pickle vs ONNX）

学習済モデルを保存・読込する 3 通りの方法を比較。 本番運用では joblib か ONNX が標準 です。

🐍 Python 実装（コード ⑤）

🎯 このコードでやること：sklearn モデルを joblib で保存し、 ファイルサイズと読込速度を確認。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

import joblib, pickle, os, time
from sklearn.ensemble import RandomForestRegressor

# X, y は直前の回帰ベンチ（出生数・出生率・気温 → 総人口）。y は連続値なので回帰器で学習する
model = RandomForestRegressor(n_estimators=100, random_state=0).fit(X, y)

# 保存
joblib.dump(model, 'model.joblib')
with open('model.pkl', 'wb') as f:
    pickle.dump(model, f)

# サイズ比較
for path in ['model.joblib', 'model.pkl']:
    print(f'{path}: {os.path.getsize(path)/1024:.1f} KB')

# 読込速度
for path, loader in [('model.joblib', joblib.load), ('model.pkl', lambda p: pickle.load(open(p, 'rb')))]:
    t0 = time.time()
    _ = loader(path)
    print(f'{path} load: {(time.time()-t0)*1000:.1f} ms')

📤 実行例:

💬 結果の読み方：100 本の木を持つ回帰フォレストは joblib で 445.3 KB、 pickle で 438.3 KB とほぼ同じ大きさで、 joblib は既定では圧縮しない（compress=3 などを指定すると小さくなる）。 読み込みもこの規模では pickle の 0.6 ms に対し joblib 3.7 ms と、 joblib が速いわけではない。 joblib の利点は大きな NumPy 配列を効率よく書き出せる点にあり、 sklearn 公式も joblib を推奨している。 ONNX に変換すると Python 非依存で C++ / JavaScript / .NET から読込でき、 サービング基盤に最適。

✅ ライブラリ選定 15 項目チェックリスト

1. タスクの種類（分類 / 回帰 / クラスタリング / 生成）が明確か
2. データ規模（n, 特徴量数）に対して適切か
3. GPU が必須か（NLP / 画像で必須、 表形式は CPU 可）
4. ライセンス（商用利用可否）を確認したか
5. 事前学習モデル動物園が必要か
6. 本番運用ターゲット（クラウド / オンプレ / エッジ）に合うか
7. サービング基盤との接続性（ONNX / TF Serving / TorchServe）
8. 分散学習対応か（Horovod / DDP / TF MirroredStrategy）
9. 説明性ツールとの連携（SHAP / LIME）が容易か
10. 監視・モニタリング（MLflow / Weights & Biases）連携か
11. Python 以外の言語からも呼び出すか
12. パイプライン化（Pipeline / Pipelines）の容易さ
13. ドキュメント・チュートリアルの充実度
14. コミュニティ規模・更新頻度
15. 類似プロジェクトでの採用実績

🧮 数式に値を入れて手で計算する: ライブラリ別速度比

合成データで 4 ライブラリの実行時間と速度比を計算する。

Step 1: 同一タスク実行時間 [秒]

Step 2: 最速 vs 最遅

🐍 Python で再現

1
2
3
4
5

import numpy as np
times = np.array([10, 30, 1, 2])
speed_ratio = 10 / times
print(f"速度比 (sklearn=1): {speed_ratio}")
print(f"最速倍率: {times.max()/times.min()} 倍")

📤 実行結果

💬 手計算 (Step 2) 30 倍と Python 出力が完全一致。

🐍 Python 実装

上の 📐 で「fit は損失関数の最小化を内部で解いている」と書いた。 これを実際に確かめる。 同じ最小二乗回帰を、 線形代数で直接解く NumPy、 fit() を呼ぶだけの scikit-learn、 損失関数を自分で書いて汎用の最適化器に渡す SciPy の 3 通りで解き、 係数が一致するかを見る。

🎯 このコードでやること：2023 年度の 47 都道府県で「総人口 ＝ 切片 ＋ 出生数 ＋ 死亡数」の最小二乗回帰を NumPy・scikit-learn・SciPy の 3 つのライブラリで解き、係数と損失 L(θ) を並べる。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

import numpy as np, pandas as pd
from sklearn.linear_model import LinearRegression
from scipy.optimize import minimize

df = pd.read_csv('data/raw/SSDSE-B-2026.csv', encoding='cp932', skiprows=[1])
d = df[df['SSDSE-B-2026'] == 2023]                         # 2023 年度の 47 都道府県
X = (d[['A4101', 'A4200']] / 1000).to_numpy()              # 出生数・死亡数（千人）
y = (d['A1101'] / 10000).to_numpy()                         # 総人口（万人）
A = np.column_stack([np.ones(len(X)), X])                   # 切片の列を足した計画行列

# ① NumPy：最小二乗 argmin ||y − Aθ||² を線形代数で直接解く
th_np, *_ = np.linalg.lstsq(A, y, rcond=None)
# ② scikit-learn：fit() の中で同じ問題が解かれる
m = LinearRegression().fit(X, y)
th_sk = np.r_[m.intercept_, m.coef_]
# ③ SciPy：損失関数 L(θ) を自分で書き、汎用の最適化器で最小化する
L = lambda th: np.sum((y - A @ th) ** 2)
th_sp = minimize(L, x0=np.zeros(3), method='BFGS').x

for name, th in [('NumPy lstsq', th_np), ('sklearn fit', th_sk), ('SciPy minimize', th_sp)]:
    print(f'{name:15s} 切片={th[0]:8.3f}  出生={th[1]:7.4f}  死亡={th[2]:7.4f}  L={L(th):,.2f}')
print(f'sklearn と NumPy の係数の差の最大 = {np.abs(th_sk - th_np).max():.1e}')
print(f'SciPy と NumPy の係数の差の最大   = {np.abs(th_sp - th_np).max():.1e}')

💬 3 つのライブラリの係数は小数第 4 位まで同じで、切片 −13.997 万人、出生数 1 千人あたり 10.47 万人、死亡数 1 千人あたり 3.48 万人、残差平方和 L = 11,835.75 になった。scikit-learn と NumPy の差は 5×10⁻¹⁴ で計算機の丸め誤差の大きさ、SciPy の BFGS は反復で近づく方法なので差が 2×10⁻⁶ 残る。fit() は魔法ではなく「損失を最小にする θ を探す」同じ問題を、ライブラリごとに違う解き方で解いているだけだと分かる。単位を千人・万人にそろえたのは、桁が大きく違う列をそのまま渡すと解き方によっては係数がずれることがあるため。

🐍 即使えるミニスニペット集

スニペット ①：sklearn fit/predict

🎯 やること：最小のロジスティック回帰。

1
2
3
4
5
6

from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import make_pipeline
yb = (y > np.median(y)).astype(int)            # 出生数が中央値を超えるか（0/1 のラベル）
m = make_pipeline(StandardScaler(), LogisticRegression()).fit(X, yb); yhat = m.predict(X)
print(yhat[:10], f'正解率 {(yhat == yb).mean():.3f}')

📤 出力: [1 1 1 1 1 1 1 1 1 1] 正解率 0.915   💬 出生数が中央値を超えるかを総人口・65 歳以上人口から当て、 564 行の 91.5% が当たった。 先頭 10 行は北海道の 2023〜2014 年度で、 どれも出生数が中央値を超えるので 1 が並ぶ。 fit/predict の 2 語で学習と予測が済むのが sklearn の統一 API。

スニペット ②：PyTorch 最小モデル定義

🎯 やること：Sequential で 2 層 MLP。

1
2

import torch.nn as nn
net = nn.Sequential(nn.Linear(10, 32), nn.ReLU(), nn.Linear(32, 3))

📤 出力: Sequential(...)   💬 入力 10 次元 → 中間 32 → 出力 3 クラス。

スニペット ③：Hugging Face で BERT 推論

🎯 やること：感情分析パイプラインを 3 行で。

1
2
3

from transformers import pipeline
clf = pipeline('sentiment-analysis')
clf('今日は最高だった')

📤 出力（初回にモデルのダウンロードが必要なため実測ではない。 返り値の形の例）: [{'label':'POSITIVE','score':0.99}]   💬 model を指定しないと英語の distilbert-base-uncased-finetuned-sst-2-english が既定で読み込まれるので、 日本語の文を入れても意味のある判定にはならない。 日本語なら日本語で学習したモデルを model= で指定する。

スニペット ④：LightGBM Optuna 最適化

🎯 やること：5 試行でハイパラ最適化。

1
2
3
4
5

import optuna, lightgbm as lgb
def obj(t):
    p = {'num_leaves': t.suggest_int('nl', 8, 128)}
    return lgb.LGBMClassifier(**p, n_jobs=1).fit(Xtr, ytr).score(Xte, yte)
study = optuna.create_study(direction='maximize'); study.optimize(obj, n_trials=5)

📤 出力: 5 試行すべて value=0.333（best=0.333）   💬 num_leaves を 8〜128 で振っても正解率は 0.333 から動かない。 学習用 32 県では LightGBM の min_child_samples=20 のせいで木が 1 度も分割されず、 num_leaves が効く余地が無いためで、 探索する前にデータ量に合わない既定値を直す必要がある。 Optuna は乱数の種を固定していないので、 試される num_leaves は実行ごとに変わる。

🐍 インストール・セットアップガイド（OS 別）

macOS (Apple Silicon)

🎯 やること：Apple Silicon (M1/M2/M3) で標準スタック構築。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# Homebrew で OpenMP（LightGBM 必須）
brew install libomp

# pyenv + Python 3.11
brew install pyenv; pyenv install 3.11.6

# 基本パッケージ
pip install numpy pandas scikit-learn xgboost lightgbm matplotlib jupyter

# PyTorch (MPS バックエンド)
pip install torch torchvision torchaudio

📤 確認: python -c "import torch; print(torch.backends.mps.is_available())"   💬 True なら GPU 利用可能。

Windows + CUDA

🎯 やること：NVIDIA GPU を使う環境構築。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

# NVIDIA Driver + CUDA Toolkit 12.x をインストール
# conda で環境隔離推奨
conda create -n ml python=3.11
conda activate ml

# PyTorch (CUDA 12.1)
pip install torch --index-url https://download.pytorch.org/whl/cu121

# TensorFlow (GPU)
pip install tensorflow[and-cuda]

📤 確認: torch.cuda.is_available() True   💬 CUDA バージョン一致が最大の落とし穴。

Google Colab

🎯 やること：無料 GPU で即環境立ち上げ。

1
2
3
4
5
6
7

# Colab には基本パッケージ済み
# 追加分のみ pip install
!pip install -q lightgbm transformers accelerate

# データを Drive から読込
from google.colab import drive
drive.mount('/content/drive')

📤 確認: ランタイム → ランタイムのタイプ → T4 GPU   💬 セッション 12 時間制限あり。

⚠️ よくある落とし穴

ライブラリの落とし穴は、 アルゴリズムの理解不足よりも「既定値・バージョン・前処理の持ち方」から来ることが多い。 同じ 1 行のコードでも、 これらが違えば結果が変わる。

⚠️ よくある落とし穴（5 件）

「機械学習ライブラリ」を実務・試験で扱うときに頻発する典型的なミスです。

⚠️ バージョン互換とライセンスの罠（10 件）

1. sklearn 0.24 → 1.0 の破壊的変更：fit_transform の戻り値が変わるケースあり。
2. TensorFlow 1 → 2：sess.run() ベースから eager execution へ。 既存コード書き換え必須。
3. PyTorch CUDA バージョン：torch のバイナリと CUDA Toolkit のバージョン一致が必要。
4. XGBoost label encoder：1.x で warning、 2.x で use_label_encoder=False が必須。
5. LightGBM 環境変数：macOS では libomp が必要。 brew install libomp。
6. Transformers のモデル ID 変更：HF 側でリネームされると from_pretrained が失敗。
7. numpy 2.0 の後方互換：np.float → float、 np.int → int の変更で旧コード壊れる。
8. pandas 2.0 の型推論：CSV 読み込みのデフォルト dtype が変化。
9. GPL 汚染：fastText など GPL ライブラリを使うと、 自社製品も GPL になる場合あり。
10. 商用利用制限：一部モデル (Meta Llama など) は商用利用に許諾必要。

⚠️ ライブラリ選定の落とし穴 7 選

ライブラリ選定はプロジェクトの成否を分ける重要な意思決定だが、 初学者ほど「流行っているから」「論文が出ているから」という理由で選んでしまいがちである。 ここでは現場で繰り返し発生する 7 つの典型的失敗を、 SSDSE-B-2026 や実プロジェクトの例とともに整理する。

💡 特に #1 と #5 は SSDSE データコンペで頻発する失敗。 「ニューラルネットを使えば加点される」と思い込んで Q5 を逃すチームが毎年いる。 47 都道府県データなら線形回帰や LightGBM で十分、 random_state を固定して再現性を担保することが最優先。

✅ 理解度チェック（機械学習ライブラリ）

以下の 5 問に答えられれば、 ライブラリ選定で大きな失敗をすることはほぼなくなる。 解答は折り畳まずに併記してあるので、 まず自分で考えてから読み進めてほしい。

💡 「ライブラリは多く触るほど偉い」は誤解。 まずは scikit-learn を 3 ヶ月深く掘る方が、 5 ライブラリを浅く触るより実務で報われる。 入門から実務まで通じる軸を 1 本持ち、 必要に応じて隣接ライブラリへ広げていくのが鉄則。

📋 SSDSE-B-2026 で実際に確認できる「ライブラリ依存度」マップ

機械学習プロジェクトを 1 本通すと、 想像以上に多くのライブラリに依存することになる。 SSDSE-B-2026 を題材に「出生数・死亡数から総人口を予測する」という単純なタスクを実装するだけでも、 以下のように 6 種類以上のライブラリが呼ばれている。 これらの依存関係を意識して `requirements.txt` を整備しておくと、 数年後の再現性が劇的に上がる。

この 6 工程の依存ライブラリは、 ① 互いに API を合わせる「エコシステム」を成しており、 ② numpy がすべての土台にあり、 ③ pandas が CSV / DataFrame 層、 ④ scikit-learn が「fit / predict / transform」の三大インターフェースを提供する、 という階層構造で理解するとよい。 LightGBM や XGBoost、 PyTorch も scikit-learn 互換のラッパーを提供しているため、 scikit-learn のインターフェースを暗記すれば他ライブラリへの移行コストは劇的に下がる。

💡 実務での再現性確保のため、 requirements.txt にバージョン明記 + pyproject.toml で Python バージョン固定 + Docker でランタイム固定 の三層防御が鉄則。 SSDSE データコンペでも、 提出時に「動かない」となるチームの大半はバージョン未固定が原因。

🛡 ライブラリの「枯れ度」と長期保守性チェックリスト

ライブラリの寿命は意外と短い。 流行りで採用したライブラリが 2 年後にメンテ停止し、 セキュリティ修正も止まる、 という事態は珍しくない。 業務でライブラリを選ぶ際は 「枯れ度（成熟度）」を以下のチェックリストで定量評価すると失敗が激減する。

上記 6 項目で 5 つ以上 ◎ が付くライブラリを選べば、 ほぼ間違いがない。 逆に「Star 数 500」「直近コミット 0」「メンテナー 1 名」のような状態のライブラリは、 たとえ論文で話題になっていても採用を避けた方がよい。 自分が業務で使い続ける数年間、 その依存先がきちんと動き続けるかを 選定時点で見抜く目を養うことが、 本当の意味での「ライブラリの使いこなし」である。

📅 ライブラリ業界の歴史と今後の展望

機械学習ライブラリの歴史を俯瞰すると、 およそ 5 年周期で主流ツールが交代している。 2010 年代前半は Theano と Caffe が主役だったが、 2015 年に TensorFlow が登場すると一気に置き換わった。 2017 年に PyTorch が研究者の支持を獲得し、 2019 年以降は研究領域で PyTorch が圧倒的優位。 産業界では TensorFlow / Keras と PyTorch がほぼ拮抗、 古典 ML の領域では scikit-learn が 2007 年から 18 年以上にわたって標準の座を守り続けている。 一方で XGBoost（2014 年公開）、 LightGBM（2016 年公開）、 CatBoost（2017 年公開）といった勾配ブースティング系も Kaggle 上位入賞の定番として定着した。

2026 年現在、 注目すべき潮流は ① コンパイラ統合（PyTorch 2.x の torch.compile、 JAX の XLA）、 ② 大規模言語モデル特化フレームワーク（Hugging Face Transformers、 vLLM）、 ③ AutoML 統合（PyCaret、 H2O AutoML）の 3 点である。 学習者の戦略としては「scikit-learn を 1 つの軸として保ちつつ、 PyTorch を第二の軸として学習」「LLM が必要になったら Hugging Face」「業務効率化なら PyCaret」というロードマップが現実的。 5 年後にも残っている可能性が高いのは、 scikit-learn / PyTorch / Hugging Face / LightGBM の 4 本柱と見られている。

💡 「最新のライブラリを追い続ける」のは消耗が激しい。 むしろ 「3 年以上残りそうなものに早く投資する」方が長期的にはリターンが大きい。 SSDSE データコンペの題材なら、 scikit-learn と LightGBM を深く理解しておけば 5 年先まで通用する。

🧭 ライブラリ選定 まとめチャート

最後に、 本ページで学んだライブラリ選定の知識を 1 枚のチャートに凝縮する。 業務やコンペで「どのライブラリを使うべきか」迷ったときは、 このチャートを上から順に当てはめれば 9 割以上のケースでは正解にたどり着ける。

このチャートを SSDSE-B-2026 に当てはめると、 「データ件数 47 件（1 万件未満）→ Yes → scikit-learn / LightGBM」で即座に結論が出る。 ニューラルネットを検討する必要はそもそもない、 ということが視覚的に確認できる。 同じ要領で「電子カルテ 100 万件の分類」「画像 50 万枚の異常検知」「テキスト 1000 万件の感情分析」などの題材についても、 適切なライブラリ候補が機械的に絞り込める。

本章の結論をひと言で言えば、 「データ規模と目的を最初に決め、 そこから機械的にライブラリを選ぶ」こと。 「流行りで選ぶ」「論文で選ぶ」「研究室の慣習で選ぶ」のいずれも実務では危険であり、 自分のプロジェクト要件と照らし合わせて選定根拠を文書化することが、 長期的なメンテナンス性と再現性を担保する第一歩である。 これでライブラリ選定の体系的な知識は完成、 あとは実プロジェクトで手を動かして体得していけば、 1 年で「ライブラリ選定で迷わないエンジニア」になれる。 この一連の流れを暗記するだけでなく、 自分の言葉で説明できるレベルまで落とし込めば、 採用面接や案件提案でも自信を持って語れるようになる、 ということを最後に強調しておきたい。 ライブラリは道具に過ぎないが、 道具を熟知することが結果として大きな差を生む。

📚 ライブラリ選定の実プロジェクト 3 事例

理論だけでは実感が掴みにくいので、 実際の業務やコンペで遭遇した 3 つの典型的なライブラリ選定事例を紹介する。 いずれも「データ規模」「予測精度の目標」「運用コスト」のトレードオフを実例で示している。

💡 事例 A → B → C と進むにつれ データ規模が 47 件 → 5 万件 → 50 万件と段階的に大きくなり、 それに応じて採用ライブラリも「シンプル → 中量級 → 重量級」へシフトしている。 この対応関係を体感できれば、 ライブラリ選定で迷うことはほぼなくなる。

🧭 タスク別ライブラリ選定ガイド（実務判断のフローチャート）

機械学習プロジェクトで「どのライブラリを使うか」は最初の重要分岐である。 ここではタスク種別・データ量・運用要件の3軸でライブラリ選定の判断基準を整理する。 SSDSE-B-2026 のような数十〜数千件規模の表形式データであれば、 scikit-learn を主軸として PyTorch/TensorFlow は補助的に使う構成が最も効率的である。 ライブラリ選びを誤ると、 GPU 環境構築に数日溶かす、 過剰なフレームワークで保守コストが膨らむ、 等のリスクがある。

📌 判断のコツ: 「ベースライン構築」→ scikit-learn、 「精度を限界まで詰める」→ LightGBM/XGBoost、 「画像・音声・テキスト」→ PyTorch/Transformers、 「統計的有意性も知りたい」→ statsmodels の4分岐で9割は決まる。 SSDSE-B-2026 のようなコンペ用途では、 まず scikit-learn の LinearRegression でベースライン、 次に RandomForestRegressor、 さらに精度が必要なら LightGBM、 という段階的アプローチが推奨される。

よくある選定ミスとその回避策

• 「とりあえずディープラーニング」病: 47都道府県程度のデータで深層学習を使うのは過剰。 線形回帰や決定木で十分な精度が出ることが多い。 まず単純なモデルでベースライン、 不満足なら複雑化、 が鉄則。
• GPU 環境構築で時間溶かし: scikit-learn・LightGBM は CPU で動くため、 Google Colab の無料枠で十分。 GPU が必要になるのは画像・テキスト・100万行以上の表形式のみ。
• 本番でフレームワーク混在: 訓練 PyTorch・推論 TensorFlow のようなクロス利用は ONNX 経由で可能だがバグ温床。 訓練と推論はできるだけ同一フレームワーク。
• バージョン地獄: scikit-learn 1.0 → 1.3 で API が変更されることがある。 requirements.txt でバージョン固定し、 再現性を確保すべし。

📊 主要ライブラリ徹底比較表（API・性能・学習コスト）

scikit-learn / PyTorch / TensorFlow / LightGBM / XGBoost / statsmodels の6つは「データ分析の主役ライブラリ」と呼べる存在である。 ここでは API 設計思想、 計算性能、 学習コスト、 コミュニティ規模、 SSDSE-B-2026 でのユースケースまで含めて多角的に比較する。 ライブラリの相対的位置づけを理解することで、 「なぜこの場面ではこれを選ぶのか」を自分の言葉で説明できるようになる。

API 設計思想の違い

性能ベンチマーク（SSDSE-B-2026 47行・15特徴量、 同一マシン）

💡 SSDSE-B-2026 規模では、 PyTorch でも 3秒で学習が終わるが、 線形回帰なら 0.002秒（1500倍速い）。 「データが小さければ古典的な手法ほど効率的」という法則は揺るがない。 ライブラリの強さは「規模に応じた使い分け」で初めて発揮される。

学習コスト・コミュニティ規模（2026年時点）

💡 「人気＝学ぶべき」ではない。 SSDSE-B-2026 のような表形式データなら scikit-learn と LightGBM の2本立てで圧倒的に十分。 PyTorch を学ぶのは画像・テキスト・音声に取り組む段階で良い。 学習順序は「scikit-learn → statsmodels → LightGBM → PyTorch」が最も挫折しにくい。

📜 機械学習ライブラリの歴史と進化の系譜

機械学習ライブラリの歴史を理解することは、 現在の API 設計や思想を腹落ちさせる近道である。 1990年代の MATLAB・R から始まり、 Python 主流時代（2007〜）、 ディープラーニング革命（2012〜）、 そして大規模言語モデル時代（2022〜）まで、 ライブラリは時代の要請に応じて進化してきた。 SSDSE-B-2026 のような統計教育用途で使うライブラリ群（scikit-learn / pandas / matplotlib）も、 すべてこの歴史の中で生まれた。

年表で見るライブラリ進化

系譜から学ぶ「廃れにくいスキル」

15年以上の歴史を見ると、 ライブラリは「主役交代」が頻繁に起こる（Theano→TensorFlow→PyTorch、 XGBoost→LightGBM 等）。 一方で scikit-learn の fit/predict API・pandas の DataFrame・NumPy の配列演算はほぼ変わらず使われ続けている。 つまり「基盤ライブラリの根幹 API」「数学的概念（線形代数・確率統計）」「データ前処理の習熟」は廃れにくい。 一方で「特定フレームワークの細かい記法」は5年で陳腐化することがある。

• 長期投資すべきスキル: pandas/NumPy の操作、 scikit-learn の API 理解、 確率統計の理論、 線形代数
• 中期投資すべきスキル: PyTorch の基本、 LightGBM/XGBoost の使い分け、 SHAP による説明性
• 短期投資（陳腐化リスク高）: 特定ベンダーの AutoML、 流行りの LLM ラッパー、 ベータ版フレームワーク

💡 SSDSE-B-2026 のような統計教育用データに取り組むのは、 「廃れにくいスキル」を鍛える絶好の機会である。 線形回帰・決定木・PCA といった古典的手法は今後30年以上使われ続けるはずで、 これらを実データで腹落ちさせれば一生の財産になる。

関連用語（ライブラリ系譜）

scikit-learn ｜ PyTorch ｜ TensorFlow ｜ pandas ｜ NumPy ｜ LightGBM ｜ XGBoost ｜ statsmodels ｜ Transformers ｜ JAX ｜ matplotlib ｜ seaborn ｜ SHAP ｜ ONNX ｜ HuggingFace

🌐 関連手法・派生

「機械学習ライブラリ」と同じ系統で覚えると効率的な手法・概念：

🌐 エコシステム関連用語

🔗 関連用語（前提・並列・発展）

📘 前提となる用語

「機械学習ライブラリ」を理解する前に押さえておきたい基礎概念：

📗 並列・対比される用語

同じ抽象度で並べて比較すると理解が深まる用語：

📕 発展・関連派生

「機械学習ライブラリ」を起点に学習を進めると次に出会う応用・派生：

📚 関連グループ教材

「機械学習ライブラリ」を含むカテゴリ「MLOps」の全体像を学べる横断教材：

• 📚 機械学習の基礎 — このカテゴリの全体像
• 📚 MLOps 概観 — このカテゴリの全体像

用語単独の理解だけでなく、 グループ教材で 前後関係・全体構造を掴むと、 実務・試験ともに応用が効きます。

📚 まとめカード — 30 秒で復習

• 選定基準: (1) 用途 (2) 性能 (3) エコシステム (4) ライセンス
• 表形式 → sklearn / LightGBM / XGBoost
• DL → PyTorch (研究) / TensorFlow (本番) / Keras (入門)
• LLM → Hugging Face Transformers
• 本ページ実値: 47 県の 3 クラス分類で sklearn-RF 0.733 / XGB 0.800 / LGB 0.333 / PyTorch 0.600、 LightGBM の 5-fold CV は 0.320±0.016 ── LightGBM は既定の min_child_samples=20 で 1 度も分割できず当てずっぽう (0.333) のまま。 小標本ではライブラリの差より既定値の合う・合わないが結果を決める
• パイプライン化が本番運用の鉄則（リーク防止 + 再現性）
• 関連用語: scikit-learn, PyTorch, TensorFlow, XGBoost, LightGBM

📝 試験・面接で頻出 Q&A 10 選

1. Q: sklearn と PyTorch の使い分けは？ A: 表形式・小〜中規模は sklearn、 画像 / NLP / 大規模 DL は PyTorch。
2. Q: PyTorch と TensorFlow の違いは？ A: PyTorch は define-by-run で柔軟、 TF は graph 中心でサービング強い。
3. Q: XGBoost と LightGBM の違いは？ A: アルゴリズム微妙に違うが、 LightGBM が高速。 結果は近い。
4. Q: Keras と PyTorch Lightning の比較は？ A: どちらも高水準 API。 Keras は TF 統合、 Lightning は PyTorch 統合。
5. Q: 古典 ML より DL が勝つ閾値は？ A: データ量とタスク次第。 表形式は数十万まで GBDT が強い。
6. Q: JAX の特徴は？ A: 関数型 + 自動微分 + 自動並列化。 numpy 互換 API。
7. Q: Pipeline を使う理由は？ A: 前処理リーク防止、 再現性、 ハイパラ最適化の対象拡張。
8. Q: ColumnTransformer の役割は？ A: 数値・カテゴリで異なる前処理を 1 オブジェクトに統合。
9. Q: BSD と Apache 2 の違いは？ A: Apache 2 は特許条項あり。 商用利用は両者 OK。
10. Q: pip と conda の使い分け？ A: pip は Python ライブラリ、 conda は Python 外 (CUDA など) も含む。

🗺 概念マップ

機械学習ライブラリを中心に、 数値計算 (NumPy / SciPy)・古典 ML (scikit-learn / XGBoost)・DL (PyTorch / TF / JAX)・NLP/LLM (Transformers)・運用 (MLflow / Kubeflow) の 5 層を整理した概念マップ。

scikit-learn は SSDSE-B-2026 のような表データに最適、 PyTorch は画像/系列/言語モデルに、 XGBoost / LightGBM は表データで高精度を狙うときに選ぶ。

🔗 隣接手法への橋渡し

機械学習ライブラリは単独で動作せず、 上流の Python 環境 (venv / conda / poetry)、 並列のフレームワーク (scikit-learn / PyTorch / TensorFlow / XGBoost)、 下流の MLOps (MLflow / Kubeflow / BentoML) と組み合わせて開発・運用パイプラインを形成する。

• 上流 (前段処理): Python 環境構築 / 依存解決 — pip / conda / poetry で再現性を確保
• 並列 (代替/比較): GUI ツール / AutoML — コード不要のローコード代替
• 下流 (後段活用): 実験管理 / モデル登録 — MLflow / Weights & Biases で履歴管理

SSDSE-B-2026 を題材にすると、 上流で pandas で CSV 読込、 中段で scikit-learn で線形回帰 → LightGBM → SHAP、 下流で MLflow に実験記録、 という pipeline が現実的な学習フロー。 GPU は不要、 CPU 数秒で全工程完了する。

🌳 手法選択フロー

ML ライブラリ選択は、 (1) タスク種別 (古典 ML / 深層学習 / 勾配ブースティング)、 (2) チーム経験、 (3) 推論環境 (サーバ / モバイル / エッジ)、 で判断する。 scikit-learn を共通土台に、 重い学習は専門ライブラリへ切替えるのが定石。

1. Step 1: タスクの種類は?
   • 古典 ML (回帰 / 分類 / クラスタリング) → scikit-learn (API 統一・前処理充実)
   • 勾配ブースティング (表形式データ) → XGBoost / LightGBM / CatBoost
   • 深層学習 (画像 / 音声 / NLP) → PyTorch (研究) / TensorFlow + Keras (本番)
   • LLM / Transformer → Hugging Face transformers + accelerate
2. Step 2: 開発体制・経験は?
   • Python のみ → scikit-learn + PyTorch で OK
   • 研究志向 (実験速度重視) → PyTorch + Lightning
   • 本番志向 (デプロイ重視) → TensorFlow + TFX または PyTorch + TorchServe
   • 非エンジニア参加 → AutoML (Auto-sklearn / H2O / Google AutoML)
3. Step 3: 推論環境は?
   • サーバ (REST API) → FastAPI + scikit-learn / PyTorch + TorchScript
   • モバイル → TensorFlow Lite / Core ML / ONNX Runtime
   • エッジ (組込) → TFLite Micro / Edge Impulse
   • ブラウザ → TensorFlow.js / ONNX.js

SSDSE-B-2026 のような表形式 47 行データでは scikit-learn + LightGBM が第一選択。 PyTorch / TensorFlow は深層学習が必要な画像・テキストタスクまで使わない。 ライブラリ選定で迷ったら「scikit-learn API 互換か?」「ドキュメントが豊富か?」「コミュニティ規模 (GitHub stars)」を基準にすると失敗しにくい。

🎮 ライブラリ選択の意思決定ツール

「どのライブラリを使うか」は流行ではなく タスクの性質から逆算して決める道具選びである。 fit/predict の使い方（scikit-learn）や深層学習フレームワークの中身（PyTorch / TensorFlow）ではなく、 ここでは 「この状況ならどれを選ぶべきか」という意思決定そのものを、 3 つの触れる道具で確かめる。 ロジックはすべて明示ルール（下記の理由表示）で、 ブラックボックスではない。