7. 分類¶

本章では、機械学習における基本的な分類（Classification） モデルとして、ロジスティック回帰、ナイーブベイズ、k-近傍法、サポートベクターマシン（SVM） を学びます。あわせて、分類モデルを評価するための指標（正解率、混同行列、適合率、再現率、F1 スコア）についても扱います。

まず、分類問題の基礎を確認しておきましょう。分類問題は大きく以下の 2 つに分けることができます。

graph TB
    A("分類問題") --> B("2値分類<br/>Binary Classification")
    A --> C("多値分類<br/>Multi-class Classification")

    B --> B1("2つのクラスに分類<br/>例: スパム判定 Yes/No<br/>病気の有無 有/無")
    C --> C1("3つ以上のクラスに分類<br/>例: アヤメの種類 3種<br/>手書き数字 0-9")

    classDef data fill:#D9EAF3,stroke:#0072B2,stroke-width:2px,color:#000
    classDef proc fill:#D9F0EA,stroke:#009E73,stroke-width:2px,color:#000
    classDef neu fill:#F2F2F2,stroke:#8C8C8C,stroke-width:2px,color:#000
    class A neu
    class B,B1 data
    class C,C1 proc

2 値分類（Binary Classification）：

• 正解ラベルが 2 つ（Yes/No、True/False、0/1 など）
• 例：メールがスパムかどうか、病気の有無

多値分類（Multi-class Classification）：

• 正解ラベルが 3 つ以上
• 例：アヤメの種類（3 種）、手書き数字（0-9 の 10 種類）

7.1 ロジスティック回帰¶

7.1.1 ロジスティック回帰とは¶

ロジスティック回帰（Logistic Regression） は、名前に「回帰」とついていますが、分類 のためのアルゴリズムです。

線形回帰では \(y = ax + b\) という式で数値を予測しましたが、ロジスティック回帰では シグモイド関数 を使って、0 から 1 の間の確率を出力します。

graph LR
    A("入力<br/>x") --> B("線形結合<br/>z = w·x + b")
    B --> C("シグモイド関数<br/>σz = 1/1+e⁻ᶻ")
    C --> D("確率<br/>0 ≤ P ≤ 1")
    D --> E("分類<br/>P ≥ 0.5 → クラス1<br/>P < 0.5 → クラス0")

    classDef data fill:#D9EAF3,stroke:#0072B2,stroke-width:2px,color:#000
    classDef proc fill:#D9F0EA,stroke:#009E73,stroke-width:2px,color:#000
    classDef out fill:#F5ECE2,stroke:#BF8040,stroke-width:2px,color:#000
    class A data
    class B,C proc
    class D,E out

7.1.2 ロジスティック回帰の実装¶

scikit-learn でロジスティック回帰を実装するには、sklearn.linear_model.LogisticRegression クラスを使用します。

import pandas as pd
import numpy as np
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
import seaborn as sns

# tipsデータセットの読み込み
tips = sns.load_dataset('tips')

# データの確認
print(tips.head())

# 特徴量とラベルの分離（チップから時間帯を予測）
X = tips[['tip']]
y = tips['time'].values # Dinne or Lunch

# データ分割
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# ロジスティック回帰モデルの学習
model = LogisticRegression()
model.fit(X_train, y_train)

# 予測
y_pred = model.predict(X_test)

# 精度の計算
accuracy = accuracy_score(y_test, y_pred)
print(f"\n精度: {accuracy:.2%}")

   total_bill   tip     sex smoker  day    time  size
0       16.99  1.01  Female     No  Sun  Dinner     2
1       10.34  1.66    Male     No  Sun  Dinner     3
2       21.01  3.50    Male     No  Sun  Dinner     3
3       23.68  3.31    Male     No  Sun  Dinner     2
4       24.59  3.61  Female     No  Sun  Dinner     4

精度: 69.39%

この予測結果の詳しい評価（混同行列や適合率・再現率など）は、7.5 節で扱います。

7.1.3 多値分類への拡張¶

ロジスティック回帰は、多値分類にも対応できます。scikit-learn の LogisticRegression クラスはデフォルトで多値分類をサポートしています。クラスごとの精度・適合率・再現率・F1 スコアをまとめて確認するには sklearn.metrics.classification_report() 関数が便利です。

import numpy as np
import matplotlib.pyplot as plt
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, classification_report
import seaborn as sns

# アヤメデータセットの読み込み
iris = sns.load_dataset('iris')

# 特徴量とラベルの分離
X = iris[['sepal_length', 'sepal_width']].values
y = iris['species'].values

# データ分割
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# モデルの学習
model = LogisticRegression(max_iter=200)
model.fit(X_train, y_train)

# 予測
y_pred = model.predict(X_test)

# 精度の計算
accuracy = accuracy_score(y_test, y_pred)
print(f"精度: {accuracy:.2%}")

# 詳細なレポート
print("\n分類レポート:")
print(classification_report(y_test, y_pred))

精度: 90.00%

分類レポート:
              precision    recall  f1-score   support

      setosa       1.00      1.00      1.00        10
  versicolor       0.88      0.78      0.82         9
   virginica       0.83      0.91      0.87        11

    accuracy                           0.90        30
   macro avg       0.90      0.90      0.90        30
weighted avg       0.90      0.90      0.90        30

分類結果の可視化例

7.2 ナイーブベイズ¶

7.2.1 ナイーブベイズとは¶

ナイーブベイズ（Naive Bayes） は、ベイズの定理を使った確率的な分類手法です。「ナイーブ（単純）」という名前は、同じクラスの中では各特徴量が互いに独立であるという仮定から来ています。実際のデータでは特徴量間に依存関係があることも多いですが、この仮定の下でも実用的に動作します。

ナイーブベイズの特徴

• 学習が高速（パラメータをカウントするだけ）
• 少ないデータでも安定する
• テキスト分類（スパムフィルタなど）と相性が良い
• 特徴量の独立性を仮定するため、相関の強い特徴量があると不利

7.2.2 ベイズの定理と直感的な理解¶

ナイーブベイズの土台となる ベイズの定理 は、次の式で表されます。

ここで、\(P(C \mid X)\) はデータ \(X\) が与えられたときにクラス \(C\) である確率（事後確率）、\(P(X \mid C)\) はクラス \(C\) のデータが特徴 \(X\) を持つ確率（尤度）、\(P(C)\) はクラス \(C\) がどれくらいの割合で出現するかの確率（事前確率）、\(P(X)\) は特徴 \(X\) が観測される確率です。

ベイズの定理を直感的に理解するために、スパムメールの判定を例にとって考えてみましょう。

過去のメールデータから、次のことがわかっているとします。

• 全メールのうち、スパムの割合は 20%（\(P(\text{スパム}) = 0.2\)）
• スパムメールに「当選」という単語が含まれる確率は 60%（\(P(\text{「当選」} \mid \text{スパム}) = 0.6\)）
• 通常メールに「当選」という単語が含まれる確率は 1%（\(P(\text{「当選」} \mid \text{通常}) = 0.01\)）
• メールが通常メールかスパムメールかにかかわらず、「当選」という単語が含まれる確率は 12.8%（\(P(\text{「当選」}) = P(\text{「当選」} \mid \text{スパム}) \cdot P(\text{スパム}) + P(\text{「当選」} \mid \text{通常}) \cdot P(\text{通常}) = 0.6 \times 0.2 + 0.01 \times 0.8 = 0.128\)）

「当選」という単語を含むメールがスパムである確率は、ベイズの定理を使って次のように計算できます。

つまり、「当選」という単語を含むメールはスパムである確率が約 94% と計算されます。ナイーブベイズは、このような計算を複数の特徴量に対して行い、最も確率が高いクラスに分類します。

7.2.3 GaussianNB による分類¶

scikit-learn では、特徴量が連続値の場合に sklearn.naive_bayes.GaussianNB クラスを使います。これは、クラスごとに各特徴量が正規分布に従うと仮定するモデルです。

from sklearn.naive_bayes import GaussianNB
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
import seaborn as sns

# アヤメデータセットの読み込み
iris = sns.load_dataset('iris')

# 特徴量とラベル
X = iris[['sepal_length', 'sepal_width',
          'petal_length', 'petal_width']].values
y = iris['species'].values

# データ分割
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# ナイーブベイズモデルの学習
model = GaussianNB()
model.fit(X_train, y_train)

# 予測と精度
y_pred = model.predict(X_test)
print(f"正解率: {accuracy_score(y_test, y_pred):.2%}")

# 予測確率の確認（最初の3件）
y_proba = model.predict_proba(X_test)[:3]
print(f"\n予測確率（最初の3件）:")
print(f"{'setosa':>10s} {'versicolor':>12s} {'virginica':>10s}")
for i in range(3):
    print(f"{y_proba[i, 0]:10.4f} {y_proba[i, 1]:12.4f}"
          f" {y_proba[i, 2]:10.4f}")

正解率: 100.00%

予測確率（最初の3件）:
    setosa   versicolor  virginica
    0.0000       0.9956     0.0044
    1.0000       0.0000     0.0000
    0.0000       0.0000     1.0000

7.2.4 ナイーブベイズの種類¶

scikit-learn には、データの性質に応じた複数のナイーブベイズが用意されています。

テキスト分類（スパムフィルタ、ニュース記事の分類など）では、多項ナイーブベイズ（Multinomial Naive Bayes） が特に広く使われています。文書を単語の出現回数で表現し、各カテゴリにおける単語の出現確率からクラスを判定します。

graph LR
    A("文書") --> B("単語頻度")
    B --> C("クラスごとの<br/>単語出現確率")
    C --> D("ベイズの定理")
    D --> E("クラス確率<br/>を計算")

    classDef data fill:#D9EAF3,stroke:#0072B2,stroke-width:2px,color:#000
    classDef proc fill:#D9F0EA,stroke:#009E73,stroke-width:2px,color:#000
    classDef model fill:#F7EBF2,stroke:#CC79A7,stroke-width:2px,color:#000
    classDef out fill:#F5ECE2,stroke:#BF8040,stroke-width:2px,color:#000
    class A,B data
    class D proc
    class C model
    class E out

この場合の計算もシンプルです。「クラス \(C\) のときに単語 \(w\) が現れる確率 \(P(w|C)\)」をデータから数え、文書中の全単語についてその確率の積をとります。

たとえばスパム判定なら、「無料」「割引」「当選」などの単語がスパムに頻出することがデータから分かれば、それらを含むメールは自動的にスパム確率が高く判定されます。

7.3 k-近傍法¶

7.3.1 k-近傍法とは¶

k-近傍法（k-Nearest Neighbors, k-NN） は、新しいデータを分類するときに「最も近い k 個の訓練データ」を見て、その多数決でクラスを決める非常にシンプルなアルゴリズムです。

graph LR
    A("新しいデータ") --> B("訓練データとの<br/>距離を計算")
    B --> C("近い順に k 個選ぶ")
    C --> D("多数決でクラス決定")

    classDef data fill:#D9EAF3,stroke:#0072B2,stroke-width:2px,color:#000
    classDef proc fill:#D9F0EA,stroke:#009E73,stroke-width:2px,color:#000
    classDef out fill:#F5ECE2,stroke:#BF8040,stroke-width:2px,color:#000
    class A data
    class B,C proc
    class D out

k-NN の特徴

• 学習がない（怠惰学習）：訓練データをそのまま記憶するだけで、予測時に距離計算する
• 非線形な境界：複雑な決定境界を表現できる
• 解釈しやすい：「近いデータと同じクラス」という直感的なルール
• 距離に敏感：特徴量のスケールの影響を強く受けるため、通常は標準化する
• 予測が遅い：データ数が多いほど予測時の計算量が増える

7.3.2 k-近傍法の実装¶

scikit-learn で k-NN を実装するには、sklearn.neighbors.KNeighborsClassifier クラスを使用します。距離ベースの手法なので、特徴量の標準化 をセットで行うのが基本です（標準化には sklearn.preprocessing.StandardScaler クラスを使います）。

import numpy as np
from sklearn.neighbors import KNeighborsClassifier
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, classification_report
import seaborn as sns

# アヤメデータセットの読み込み
iris = sns.load_dataset('iris')
X = iris[['sepal_length', 'sepal_width', 'petal_length', 'petal_width']].values
y = iris['species'].values

# データ分割
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# 標準化（訓練データで fit、テストには transform のみ）
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# k-NN モデルの学習（k=5）
model = KNeighborsClassifier(n_neighbors=5)
model.fit(X_train_scaled, y_train)

# 予測と評価
y_pred = model.predict(X_test_scaled)
print(f"精度: {accuracy_score(y_test, y_pred):.2%}")
print("\n分類レポート:")
print(classification_report(y_test, y_pred))

精度: 100.00%

分類レポート:
              precision    recall  f1-score   support

      setosa       1.00      1.00      1.00        10
  versicolor       1.00      1.00      1.00         9
   virginica       1.00      1.00      1.00        11

    accuracy                           1.00        30
   macro avg       1.00      1.00      1.00        30
weighted avg       1.00      1.00      1.00        30

7.3.3 ハイパーパラメータ k の選び方¶

k-NN の最も重要なハイパーパラメータが n_neighbors（= k） です。

• k が小さい（例：k = 1）：1 つの近傍だけで決めるため、ノイズに敏感で 過学習しやすい
• k が大きい：広い範囲を見るため境界が滑らかになるが、大きすぎると 未学習 になる

import matplotlib.pyplot as plt
from sklearn.neighbors import KNeighborsClassifier
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
import seaborn as sns

iris = sns.load_dataset('iris')
X = iris[['sepal_length', 'sepal_width', 'petal_length', 'petal_width']].values
y = iris['species'].values

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# k を変えて精度を比較
ks = range(1, 21)
train_acc, test_acc = [], []
for k in ks:
    model = KNeighborsClassifier(n_neighbors=k)
    model.fit(X_train_scaled, y_train)
    train_acc.append(model.score(X_train_scaled, y_train))
    test_acc.append(model.score(X_test_scaled, y_test))

plt.figure(figsize=(8, 5))
plt.plot(ks, train_acc, marker='o', label='訓練精度')
plt.plot(ks, test_acc, marker='s', label='テスト精度')
plt.xlabel('k (n_neighbors)')
plt.ylabel('精度')
plt.title('k-NN: k と精度の関係')
plt.legend()
plt.grid(True, alpha=0.3)
plt.show()

7.4 サポートベクターマシン¶

7.4.1 SVM とは¶

サポートベクターマシン（Support Vector Machine, SVM） は、クラスを分ける「境界」をマージン（margin）が最大になるように引く分類アルゴリズムです。ロジスティック回帰や k-近傍法と同じく「特徴量空間で境界を引く」手法ですが、SVM は「境界からデータ点までの距離（マージン）を最大化する」ことで、汎化性能の高い境界を得ることができます。

SVM の特徴

• マージン最大化：境界とデータ点の距離（マージン）が最も大きくなる境界を選ぶため、汎化性能が高い
• カーネルトリック：非線形な境界も扱える（後述）
• 少データに強い：サンプルが少ない場面でも安定して動きやすい
• 標準化を通常行う：内積やカーネルの計算が特徴量のスケールの影響を受ける
• 大規模データに弱い：学習計算量がサンプル数に対して大きい（〜サンプル数の2〜3乗）

7.4.2 線形 SVM の考え方¶

マージン最大化¶

SVM のキモは「境界線の引き方」です。2 クラスを分ける直線は無数に引けますが、SVM は「両クラスから最も遠い（＝マージンが最大の）境界」を選びます。

上図のように、同じデータでも引ける境界は無数にあります。SVM は境界から最も近いデータ点（サポートベクター、緑の丸）までの距離＝マージンが最大になる境界を選びます。マージンが大きいほど、未知のデータに対しても正しく分類できる可能性が高くなります。

数式による定式化¶

2 クラス分類（ラベル \(y_i \in \{-1, +1\}\)）で、決定境界を \(\mathbf{w} \cdot \mathbf{x} + b = 0\) とします。

ソフトマージン SVM¶

現実のデータは完全に線形分離できないことが多いため、多少の誤分類を許容する ソフトマージン SVM を使います。

上図のように、\(C\) の大きさでマージンの広さと違反の許容度が変わります。

• \(C\) 小（左）：マージンが広く、マージン内に入り込む点（\(\xi > 0\)、オレンジ破線の丸）を多く許容する。境界はシンプルだが、誤分類もやや増える
• \(C\) 大（右）：マージンが狭く、違反を厳しく罰する。サポートベクター（緑の丸、\(\xi = 0\)）のみがマージン境界上に並ぶ

7.4.3 RBF カーネルと非線形 SVM¶

なぜカーネルが必要か¶

直線では分けられないデータも存在します（下図の同心円データなど）。こうしたデータを分類するには、データを高次元空間に写像して、そこで線形に分離するというアイデアが考えられます。

graph LR
    A("元の空間（2次元）<br/>線形分離不可能") -->|"写像 φ"| B("高次元空間<br/>線形分離可能")
    B --> C("高次元で<br/>線形 SVM")
    C --> D("元の空間では<br/>非線形な境界")

    classDef data fill:#D9EAF3,stroke:#0072B2,stroke-width:2px,color:#000
    classDef model fill:#F7EBF2,stroke:#CC79A7,stroke-width:2px,color:#000
    classDef out fill:#F5ECE2,stroke:#BF8040,stroke-width:2px,color:#000
    class A,B data
    class C model
    class D out

しかし、高次元空間での計算は非常にコストがかかります。ここで登場するのが カーネルトリック です。

RBF カーネルの数式¶

最もよく使われる RBF（Radial Basis Function）カーネル は、2 つのデータ点 \(\mathbf{x}_i\) と \(\mathbf{x}_j\) の「類似度」を次のように定義します。

カーネル関数の比較¶

RBF カーネルの決定境界¶

線形分離できない同心円状のデータに対して RBF カーネル SVM を適用することで、非線形な決定境界を得ることができます。

上図のように、線形カーネルでは分離できないデータも、RBF カーネルなら非線形な境界で（高次元空間では線形な境界で）正しく分類できます。

gamma の影響の可視化¶

RBF カーネルでは gamma の値が決定境界の複雑さを大きく左右します。

7.4.4 SVM の実装¶

SVM を実装するには、sklearn.svm.SVC クラスを使用します。SVM は距離ベースの手法なので、sklearn.preprocessing.StandardScaler クラスによる標準化をセットで行うのが基本です。

from sklearn.svm import SVC
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
import seaborn as sns

# アヤメデータセットの読み込み
iris = sns.load_dataset('iris')
X = iris[['petal_length', 'petal_width']].values
y = iris['species'].values

# データ分割
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# 標準化（SVM では通常行う）
scaler = StandardScaler()
X_train_s = scaler.fit_transform(X_train)
X_test_s = scaler.transform(X_test)

# SVM モデルの学習（RBF カーネル）
model = SVC(kernel='rbf', C=1.0, gamma='scale', random_state=42)
model.fit(X_train_s, y_train)

# 予測と評価
y_pred = model.predict(X_test_s)
accuracy = accuracy_score(y_test, y_pred)
print(f"精度: {accuracy:.2%}")

7.4.5 SVM のハイパーパラメータ¶

7.5 分類モデルの評価指標¶

分類問題では、回帰問題とは異なる評価指標を使います。

graph LR
    A("分類モデルの評価指標") --> B("正解率<br/>Accuracy")
    A --> C("適合率<br/>Precision")
    A --> D("再現率<br/>Recall")
    A --> E("F1スコア<br/>F1-Score")
    A --> F("混同行列<br/>Confusion Matrix")
    A --> G("ROC曲線・AUC<br/>ROC Curve / AUC")

    B --> B1("正しく分類できた割合<br/>最も基本的な指標")
    C --> C1("Positiveと予測したうち<br/>実際にPositiveだった割合")
    D --> D1("実際のPositiveのうち<br/>Positiveと予測できた割合")
    E --> E1("適合率と再現率の<br/>調和平均")
    F --> F1("予測と実際の結果を<br/>表で表現")
    G --> G1("しきい値を変えた性能を可視化<br/>AUCで総合評価")

    classDef data fill:#D9EAF3,stroke:#0072B2,stroke-width:2px,color:#000
    classDef proc fill:#D9F0EA,stroke:#009E73,stroke-width:2px,color:#000
    classDef model fill:#F7EBF2,stroke:#CC79A7,stroke-width:2px,color:#000
    classDef out fill:#F5ECE2,stroke:#BF8040,stroke-width:2px,color:#000
    classDef hl fill:#F9E7D9,stroke:#D55E00,stroke-width:2px,color:#000
    classDef neu fill:#F2F2F2,stroke:#8C8C8C,stroke-width:2px,color:#000
    class A neu
    class B,B1,G,G1 data
    class C,C1 proc
    class D,D1 model
    class E,E1 out
    class F,F1 hl

本節のコード例では、7.1.2 で学習した tips データセットのロジスティック回帰モデルの予測結果（y_test、y_pred）をそのまま使用します。

7.5.1 正解率（Accuracy）¶

正解率 は、全体のうち正しく分類できた割合です。

scikit-learn では sklearn.metrics.accuracy_score() 関数で計算します。

from sklearn.metrics import accuracy_score

accuracy = accuracy_score(y_test, y_pred)
print(f"正解率: {accuracy:.2%}")

7.5.2 混同行列（Confusion Matrix）¶

混同行列 は、予測結果と実際の結果を表形式で表現したものです。N クラス分類なら N×N の行列 になります（2 値分類なら 2×2、アヤメのような 3 クラス分類なら 3×3）。行が「実際のクラス」、列が「予測したクラス」を表すのが一般的です。

2 値分類の場合：

• TP（True Positive）： 正しく Positive と予測
• TN（True Negative）： 正しく Negative と予測
• FP（False Positive）： 誤って Positive と予測（第一種過誤）
• FN（False Negative）： 誤って Negative と予測（第二種過誤）

多値分類の場合：対角成分が「正しく分類できた数」、それ以外が「どのクラスをどのクラスと取り違えたか」を表します。例えば 3 クラス分類で cm[1][2] の値は「実際はクラス 1 なのにクラス 2 と予測した数」を意味します。

scikit-learn では sklearn.metrics.confusion_matrix() 関数で計算します。

from sklearn.metrics import confusion_matrix
import seaborn as sns

# 混同行列
cm = confusion_matrix(y_test, y_pred)
print("混同行列:")
print(cm)

混同行列:
[[34  0]
 [15  0]]

# カテゴリ変数をダミー変数化
X = pd.get_dummies(tips[['total_bill', 'tip', 'sex', 'smoker', 'day']], drop_first=True)

7.5.3 適合率（Precision）¶

適合率（Precision） は、Positive と予測したうち、実際に Positive だった割合です。偽陽性（誤って Positive と予測すること）を減らしたいときに重視します。

scikit-learn では sklearn.metrics.precision_score() 関数で計算します。

from sklearn.metrics import precision_score

# pos_label で「Positive」とみなすクラスを指定（文字列ラベルの場合は必須）
precision = precision_score(y_test, y_pred, pos_label='Lunch')
print(f"適合率（Lunch）: {precision:.2%}")

7.5.4 再現率（Recall）¶

再現率（Recall） は、実際の Positive のうち、Positive と予測できた割合です。偽陰性（実際は Positive なのに Negative と予測してしまうこと）を減らしたいときに重視します。

scikit-learn では sklearn.metrics.recall_score() 関数で計算します。

from sklearn.metrics import recall_score

recall = recall_score(y_test, y_pred, pos_label='Lunch')
print(f"再現率（Lunch）: {recall:.2%}")

7.5.5 F1 スコア¶

F1 スコア は、適合率と再現率の調和平均です。適合率と再現率のバランスを取った指標で、両方を重視したい場合に使います。

scikit-learn では sklearn.metrics.f1_score() 関数で計算します。

from sklearn.metrics import f1_score

f1 = f1_score(y_test, y_pred, pos_label='Lunch')
print(f"F1スコア（Lunch）: {f1:.2%}")

7.5.6 ROC 曲線と AUC¶

ロジスティック回帰は確率を出力するため、「どの確率以上を Positive とみなすか」という しきい値（threshold） を変えることで、適合率と再現率のバランスを調整できます。しきい値を変えながらモデルの性能を可視化したものが ROC 曲線（Receiver Operating Characteristic Curve） です。

• 横軸：偽陽性率（FPR） = FP / (FP + TN)
• 縦軸：真陽性率（TPR） = Recall = TP / (TP + FN)

graph LR
    A("ROC曲線の見方") --> B("左上に近いほど良い<br/>FPR小・TPR大")
    A --> C("対角線=ランダム予測<br/>AUC=0.5")
    A --> D("完璧なモデル<br/>AUC=1.0")

    classDef data fill:#D9EAF3,stroke:#0072B2,stroke-width:2px,color:#000
    classDef proc fill:#D9F0EA,stroke:#009E73,stroke-width:2px,color:#000
    classDef model fill:#F7EBF2,stroke:#CC79A7,stroke-width:2px,color:#000
    classDef neu fill:#F2F2F2,stroke:#8C8C8C,stroke-width:2px,color:#000
    class A neu
    class B data
    class C proc
    class D model

AUC（Area Under the Curve） は ROC 曲線の下側の面積で、0.5（ランダム）〜 1.0（完璧）の値をとります。しきい値に依存しない単一の指標としてモデル比較に便利です。

7.1.2 の例ではモデルが「常に Dinner」と予測していたため、評価指標を実感しにくいです。ここでは特徴量を増やしたうえで ROC 曲線と AUC を計算してみます。scikit-learn では sklearn.metrics.roc_curve() 関数と sklearn.metrics.roc_auc_score() 関数を使います。

import pandas as pd
import matplotlib.pyplot as plt
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import roc_curve, roc_auc_score
import seaborn as sns

# データ準備（特徴量を増やしてダミー変数化）
tips = sns.load_dataset('tips')
X = pd.get_dummies(
    tips[['total_bill', 'tip', 'sex', 'smoker', 'day', 'size']],
    drop_first=True
)
y = (tips['time'] == 'Lunch').astype(int)  # Lunch=1, Dinner=0

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# 学習
model = LogisticRegression(max_iter=1000)
model.fit(X_train, y_train)

# Positiveクラス（Lunch=1）の予測確率を取得
y_proba = model.predict_proba(X_test)[:, 1]

# ROC曲線とAUC
fpr, tpr, thresholds = roc_curve(y_test, y_proba)
auc = roc_auc_score(y_test, y_proba)
print(f"AUC: {auc:.3f}")

# 可視化
plt.figure(figsize=(6, 6))
plt.plot(fpr, tpr, label=f'ROC (AUC = {auc:.3f})')
plt.plot([0, 1], [0, 1], 'k--', label='ランダム予測')
plt.xlabel('偽陽性率 (FPR)')
plt.ylabel('真陽性率 (TPR)')
plt.title('ROC曲線')
plt.legend()
plt.show()

7.6 演習問題¶

演習 7-1: ロジスティック回帰¶

import seaborn as sns
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

# 1. データの読み込みと先頭 5 行の表示

# 2. 特徴量 X とラベル y の設定

# 3. 訓練・テストに分割（8:2, random_state=42）

# 4. モデルの作成と学習

# 5. テストデータで予測し、正解率を表示

# 6. 係数と切片の表示

# 7. tip の 1 列だけで学習した場合との正解率比較

import seaborn as sns
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

# 1. データの読み込みと先頭5行の表示
tips = sns.load_dataset("tips")
print(tips.head())

# 2. 特徴量 X とラベル y の設定
X = tips[["total_bill", "tip", "size"]]
y = tips["time"]

# 3. 訓練データとテストデータに分割
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# 4. モデルの作成と学習
model = LogisticRegression(max_iter=1000)
model.fit(X_train, y_train)

# 5. テストデータで予測し、正解率を表示
y_pred = model.predict(X_test)
print(f"正解率: {accuracy_score(y_test, y_pred):.4f}")

# 6. 係数と切片の表示
for name, coef in zip(X.columns, model.coef_[0]):
    print(f"{name}: {coef:.4f}")
print(f"切片: {model.intercept_[0]:.4f}")

# 7. tip の1列だけを特徴量にした場合との比較
X1 = tips[["tip"]]
X1_train, X1_test, y1_train, y1_test = train_test_split(
    X1, y, test_size=0.2, random_state=42
)
model1 = LogisticRegression(max_iter=1000)
model1.fit(X1_train, y1_train)
y1_pred = model1.predict(X1_test)
print(f"正解率（tip のみ）: {accuracy_score(y1_test, y1_pred):.4f}")

   total_bill   tip     sex smoker  day    time  size
0       16.99  1.01  Female     No  Sun  Dinner     2
1       10.34  1.66    Male     No  Sun  Dinner     3
2       21.01  3.50    Male     No  Sun  Dinner     3
3       23.68  3.31    Male     No  Sun  Dinner     2
4       24.59  3.61  Female     No  Sun  Dinner     4
正解率: 0.6735
total_bill: -0.0883
tip: 0.0555
size: 0.0572
切片: 0.3732
正解率（tip のみ）: 0.6939

演習 7-2: k-近傍法の基礎¶

import seaborn as sns
from sklearn.neighbors import KNeighborsClassifier
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, classification_report

# 1. データの読み込みと特徴量 X・ラベル y の設定

# 2. 訓練・テストに分割（8:2, random_state=42）

# 3. StandardScaler で標準化

# 4. k-NN モデル（n_neighbors=5）の学習

# 5. テストデータで予測し、正解率を表示

# 6. classification_report の表示

# 7. k を変えて訓練・テスト正解率を比較

import seaborn as sns
from sklearn.neighbors import KNeighborsClassifier
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, classification_report

# 1. データの読み込みと特徴量 X・ラベル y の設定
iris = sns.load_dataset("iris")
X = iris[["sepal_length", "sepal_width",
          "petal_length", "petal_width"]]
y = iris["species"]

# 2. 訓練データとテストデータに分割
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# 3. StandardScaler で標準化
scaler = StandardScaler()
X_train_s = scaler.fit_transform(X_train)
X_test_s = scaler.transform(X_test)

# 4. k-NN モデル（n_neighbors=5）の学習
model = KNeighborsClassifier(n_neighbors=5)
model.fit(X_train_s, y_train)

# 5. テストデータで予測し、正解率を表示
y_pred = model.predict(X_test_s)
print(f"正解率: {accuracy_score(y_test, y_pred):.4f}")

# 6. classification_report の表示
print(classification_report(y_test, y_pred))

# 7. k を変えて訓練・テスト正解率を比較
for k in [1, 3, 5, 7, 9, 11, 15, 21, 31]:
    m = KNeighborsClassifier(n_neighbors=k)
    m.fit(X_train_s, y_train)
    train_acc = accuracy_score(y_train, m.predict(X_train_s))
    test_acc = accuracy_score(y_test, m.predict(X_test_s))
    print(f"k={k:2d}: 訓練 {train_acc:.4f}, テスト {test_acc:.4f}")

正解率: 1.0000
              precision    recall  f1-score   support

      setosa       1.00      1.00      1.00        10
  versicolor       1.00      1.00      1.00         9
   virginica       1.00      1.00      1.00        11

    accuracy                           1.00        30
   macro avg       1.00      1.00      1.00        30
weighted avg       1.00      1.00      1.00        30

k= 1: 訓練 1.0000, テスト 1.0000
k= 3: 訓練 0.9417, テスト 1.0000
k= 5: 訓練 0.9583, テスト 1.0000
k= 7: 訓練 0.9583, テスト 1.0000
k= 9: 訓練 0.9500, テスト 1.0000
k=11: 訓練 0.9583, テスト 1.0000
k=15: 訓練 0.9583, テスト 1.0000
k=21: 訓練 0.9500, テスト 1.0000
k=31: 訓練 0.9250, テスト 0.9667

演習 7-3: 混同行列と評価指標¶

import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import (confusion_matrix, precision_score,
                             recall_score, f1_score, classification_report)

# 1. 演習 7-1 と同じモデルを学習し、テストデータを予測

# 2. confusion_matrix の計算と表示（labels=['Dinner', 'Lunch']）

# 3. ヒートマップで混同行列を可視化

# 4. Lunch を Positive とした適合率・再現率・F1 スコア

# 5. classification_report の表示

# 6. 考察（どのクラスを間違えやすいか・なぜか）をコメントで記述

import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import (confusion_matrix, precision_score,
                             recall_score, f1_score, classification_report)

# 1. 演習 7-1 と同じモデルを学習し、テストデータを予測
tips = sns.load_dataset("tips")
X = tips[["total_bill", "tip", "size"]]
y = tips["time"]
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)
model = LogisticRegression(max_iter=1000)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

# 2. confusion_matrix の計算と表示
cm = confusion_matrix(y_test, y_pred, labels=["Dinner", "Lunch"])
print("混同行列:")
print(cm)

# 3. ヒートマップで混同行列を可視化
plt.figure(figsize=(5, 4))
sns.heatmap(cm, annot=True, fmt="d", cmap="Blues",
            xticklabels=["Dinner", "Lunch"],
            yticklabels=["Dinner", "Lunch"])
plt.xlabel("Predicted")
plt.ylabel("Actual")
plt.show()

# 4. Lunch を Positive とした適合率・再現率・F1 スコア
precision = precision_score(y_test, y_pred, pos_label="Lunch")
recall = recall_score(y_test, y_pred, pos_label="Lunch")
f1 = f1_score(y_test, y_pred, pos_label="Lunch")
print(f"適合率: {precision:.4f}")
print(f"再現率: {recall:.4f}")
print(f"F1スコア: {f1:.4f}")

# 5. classification_report の表示
print(classification_report(y_test, y_pred))

混同行列:
[[33  1]
 [15  0]]
適合率: 0.0000
再現率: 0.0000
F1スコア: 0.0000
              precision    recall  f1-score   support

      Dinner       0.69      0.97      0.80        34
       Lunch       0.00      0.00      0.00        15

    accuracy                           0.67        49
   macro avg       0.34      0.49      0.40        49
weighted avg       0.48      0.67      0.56        49

演習 7-4: 4 モデルの比較¶

import pandas as pd
import seaborn as sns
from sklearn.linear_model import LogisticRegression
from sklearn.naive_bayes import GaussianNB
from sklearn.neighbors import KNeighborsClassifier
from sklearn.svm import SVC
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import accuracy_score, f1_score

# 1. データの読み込みと特徴量・ラベルの設定

# 2. 訓練・テストに分割（8:2, random_state=42）と標準化

# 3. 4 つのモデルの正解率と F1 スコア（average='macro'）を計算

# 4. 結果を表にまとめて表示

# 5. 最も性能の高いモデルを確認

import pandas as pd
from sklearn.linear_model import LogisticRegression
from sklearn.naive_bayes import GaussianNB
from sklearn.neighbors import KNeighborsClassifier
from sklearn.svm import SVC
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import accuracy_score, f1_score
import seaborn as sns

# 1. 全特徴量を使用し、標準化を行う
iris = sns.load_dataset("iris")
X = iris[["sepal_length", "sepal_width",
          "petal_length", "petal_width"]].values
y = iris["species"].values

# 2. 訓練データとテストデータに分割
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)
scaler = StandardScaler()
X_train_s = scaler.fit_transform(X_train)
X_test_s = scaler.transform(X_test)

# 3. 4つのモデルの正解率と F1スコアを求める
models = {
    "ロジスティック回帰": LogisticRegression(
        max_iter=200, random_state=42),
    "ナイーブベイズ": GaussianNB(),
    "k-NN (k=5)": KNeighborsClassifier(n_neighbors=5),
    "SVM (RBF)": SVC(kernel="rbf", random_state=42),
}
results = []
for name, model in models.items():
    model.fit(X_train_s, y_train)
    y_pred = model.predict(X_test_s)
    acc = accuracy_score(y_test, y_pred)
    f1 = f1_score(y_test, y_pred, average="macro")
    results.append({
        "モデル": name,
        "正解率": f"{acc:.2%}",
        "F1スコア": f"{f1:.4f}"
    })

# 4. 結果を表にまとめて表示
result_df = pd.DataFrame(results)
print(result_df.to_string(index=False))

      モデル     正解率  F1スコア
ロジスティック回帰 100.00% 1.0000
  ナイーブベイズ 100.00% 1.0000
k-NN (k=5) 100.00% 1.0000
SVM (RBF) 100.00% 1.0000

演習 7-5: SVM とハイパーパラメータ¶

import seaborn as sns
from sklearn.svm import SVC
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

# 1. データの読み込みと欠損値の削除

# 2. 特徴量 X とラベル y の設定 + 訓練・テストに分割（8:2, random_state=42）

# 3. StandardScaler で標準化（訓練データで fit_transform、テストデータは transform）

# 4. 複数の C で SVM（RBF）を学習し、精度を比較

# 5. 考察をコメントで記述

import seaborn as sns
from sklearn.svm import SVC
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

# 1. データの読み込みと欠損値の削除
penguins = sns.load_dataset("penguins").dropna()

# 2. 特徴量 X とラベル y の設定 + 訓練・テストに分割
X = penguins[["bill_length_mm", "bill_depth_mm", "body_mass_g"]]
y = penguins["species"]
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# 3. StandardScaler で標準化
scaler = StandardScaler()
X_train_s = scaler.fit_transform(X_train)
X_test_s = scaler.transform(X_test)

# 4. 複数の C で SVM（RBF）を学習し、精度を比較
for C in [0.01, 0.1, 1, 10, 100]:
    model = SVC(kernel="rbf", gamma="scale", C=C, random_state=42)
    model.fit(X_train_s, y_train)
    y_pred = model.predict(X_test_s)
    acc = accuracy_score(y_test, y_pred)
    print(f"C={C:>6}: 正解率 {acc:.4f}")

C=  0.01: 正解率 0.7761
C=   0.1: 正解率 0.9851
C=     1: 正解率 1.0000
C=    10: 正解率 1.0000
C=   100: 正解率 0.9851

7.7 まとめ¶

本章では、分類問題の基礎、ロジスティック回帰、ナイーブベイズ、k-近傍法、サポートベクターマシン（SVM）について学びました。