🎯 STEP 13: 基本的な分類アルゴリズム
ロジスティック回帰、k近傍法、決定木の仕組みと実装を学びます
📋 このステップで学ぶこと
- 分類問題とは何か
- ロジスティック回帰の仕組み
- k近傍法（KNN）の原理
- 決定木の構造
- 各アルゴリズムの使い分け
- 実践：スパムメール判定
演習問題： 8問
🎯 1. 分類問題とは？
回帰 vs 分類（復習）
📚 分類（Classification）
カテゴリ（クラス）を予測する問題です。
例：
・このメールはスパム？ → スパム / 正常
・この腫瘍は悪性？ → 悪性 / 良性
・この画像は何？ → 猫 / 犬 / 鳥
・顧客は離脱する？ → はい / いいえ
| 分類のタイプ | 説明 | 例 |
|---|---|---|
| 二値分類 (Binary) |
2つのクラスに分類 | ・スパム判定（スパム/正常） ・病気診断（病気/健康） ・顧客離脱（離脱/継続） |
| 多クラス分類 (Multi-class) |
3つ以上のクラスに分類 | ・手書き数字認識（0〜9） ・花の種類（3種類） ・感情分析（喜/怒/哀/楽） |
| 多ラベル分類 (Multi-label) |
複数のラベルを同時に予測 | ・タグ付け（複数タグ可能） ・疾患予測（複数の病気） |
💡 このステップでは
二値分類を中心に学びます。多クラス分類も基本的に同じアルゴリズムで対応できます。
📈 2. ロジスティック回帰
ロジスティック回帰とは？
🔢 名前に「回帰」とあるが、実は分類アルゴリズム！
ロジスティック回帰は、確率を予測する分類手法です。
例：「このメールがスパムである確率は85%」
→ 50%以上なら「スパム」、未満なら「正常」と分類
仕組み
【線形回帰との違い】
線形回帰:
y = w₀ + w₁×x₁ + w₂×x₂ + …
→ どんな値でも出力（-∞ 〜 +∞）
ロジスティック回帰:
z = w₀ + w₁×x₁ + w₂×x₂ + …
p = 1 / (1 + e^(-z)) ← シグモイド関数
→ 0 〜 1の確率を出力
【シグモイド関数の特徴】
・入力が大きい → 1に近づく
・入力が小さい → 0に近づく
・入力が0 → 0.5
・滑らかなS字カーブ
シグモイド関数の可視化
import numpy as np
import matplotlib.pyplot as plt
# シグモイド関数
def sigmoid(z):
return 1 / (1 + np.exp(-z))
# 可視化
z = np.linspace(-10, 10, 200)
p = sigmoid(z)
plt.figure(figsize=(10, 6))
plt.plot(z, p, linewidth=3)
plt.axhline(y=0.5, color=’red’, linestyle=’–‘, linewidth=2, label=’Decision Boundary (p=0.5)’)
plt.axvline(x=0, color=’gray’, linestyle=’–‘, linewidth=1)
plt.xlabel(‘z (Linear Combination)’)
plt.ylabel(‘Probability p(y=1)’)
plt.title(‘Sigmoid Function’)
plt.legend()
plt.grid(True, alpha=0.3)
plt.ylim(-0.1, 1.1)
plt.show()
print(“=== シグモイド関数の値 ===”)
test_values = [-5, -2, -1, 0, 1, 2, 5]
for z_val in test_values:
p_val = sigmoid(z_val)
print(f”z = {z_val:2d} → p = {p_val:.4f}”)
=== シグモイド関数の値 ===
z = -5 → p = 0.0067
z = -2 → p = 0.1192
z = -1 → p = 0.2689
z = 0 → p = 0.5000
z = 1 → p = 0.7311
z = 2 → p = 0.8808
z = 5 → p = 0.9933
ロジスティック回帰の実装
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
# 二値分類データを生成
X, y = make_classification(
n_samples=200,
n_features=2,
n_informative=2,
n_redundant=0,
n_clusters_per_class=1,
random_state=42
)
# データ分割
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.3, random_state=42
)
# モデル訓練
model = LogisticRegression(random_state=42)
model.fit(X_train, y_train)
# 予測
y_pred = model.predict(X_test)
y_pred_proba = model.predict_proba(X_test) # 確率も取得
print(“=== ロジスティック回帰の結果 ===”)
print(f”正解率: {accuracy_score(y_test, y_pred):.4f}”)
# 最初の5個の予測を表示
print(“\n=== 予測の詳細（最初の5個） ===”)
print(f”{‘実際’:<6} {'予測':<6} {'クラス0の確率':<15} {'クラス1の確率':<15}")
print("-" * 50)
for i in range(5):
print(f"{y_test[i]:<6} {y_pred[i]:<6} {y_pred_proba[i][0]:<15.4f} {y_pred_proba[i][1]:<15.4f}")
=== ロジスティック回帰の結果 ===
正解率: 0.9500
=== 予測の詳細（最初の5個） ===
実際 予測 クラス0の確率 クラス1の確率
————————————————–
1 1 0.0123 0.9877
0 0 0.9234 0.0766
1 1 0.0456 0.9544
0 0 0.8976 0.1024
1 1 0.1234 0.8766
✅ ロジスティック回帰の特徴
- 確率を出力：「85%の確率でスパム」のように解釈できる
- 線形な決定境界：直線（または平面）で分類
- 高速：学習も予測も速い
- 解釈しやすい：係数から特徴量の影響がわかる
- 線形分離可能なデータに向く
- 複雑な非線形パターンは苦手
👥 3. k近傍法（KNN）
KNNの仕組み
🎯 「近くにいる人に聞いてみよう」
k近傍法（k-Nearest Neighbors）は、最もシンプルな機械学習アルゴリズムです。
手順：
1. 新しいデータポイントに最も近いk個のデータを探す
2. その多数決でクラスを決める
例：k=5の場合
近くの5人のうち、3人が「スパム」、2人が「正常」
→ このメールは「スパム」と判定
距離の計算
【ユークリッド距離（最もよく使われる）】
d = √[(x₁-x₂)² + (y₁-y₂)²]
例：
点A: (1, 2)
点B: (4, 6)
距離 = √[(4-1)² + (6-2)²]
= √[9 + 16]
= √25
= 5
【他の距離】
・マンハッタン距離: |x₁-x₂| + |y₁-y₂|
・ミンコフスキー距離: 一般化された距離
KNNの実装
from sklearn.neighbors import KNeighborsClassifier
# k=5の場合
knn_5 = KNeighborsClassifier(n_neighbors=5)
knn_5.fit(X_train, y_train)
y_pred_knn5 = knn_5.predict(X_test)
# k=1の場合
knn_1 = KNeighborsClassifier(n_neighbors=1)
knn_1.fit(X_train, y_train)
y_pred_knn1 = knn_1.predict(X_test)
# k=15の場合
knn_15 = KNeighborsClassifier(n_neighbors=15)
knn_15.fit(X_train, y_train)
y_pred_knn15 = knn_15.predict(X_test)
print(“=== kの値による性能の違い ===”)
print(f”k=1: 正解率 = {accuracy_score(y_test, y_pred_knn1):.4f}”)
print(f”k=5: 正解率 = {accuracy_score(y_test, y_pred_knn5):.4f}”)
print(f”k=15: 正解率 = {accuracy_score(y_test, y_pred_knn15):.4f}”)
=== kの値による性能の違い ===
k=1: 正解率 = 0.9000
k=5: 正解率 = 0.9333
k=15: 正解率 = 0.9167
🔍 kの値の選び方
k=1:最も近い1つだけ見る、決定境界が複雑（ノイズに敏感）、過学習しやすい
k=5〜10:バランスが良い、多くの場合で最良の選択
k=大きい:決定境界が滑らか、過学習しにくい、でも性能が下がることも
✅ KNNの特徴
- 直感的：「近くの人に聞く」という単純な発想
- 訓練が不要：データを保存するだけ
- 非線形：複雑なパターンにも対応
- 多クラス分類が自然
- 予測が遅い：全データとの距離を計算
- メモリを消費：全データを保存
- スケーリング必須：特徴量のスケールに敏感
- 高次元データでは性能低下（次元の呪い）
🌳 4. 決定木（Decision Tree）
決定木とは？
🎋 「はい/いいえ」の質問で分類
決定木は、一連の質問（条件分岐）でデータを分類します。
例：タイタニック号の生存予測
1. 性別は女性？ → はい: 生存の可能性高い / いいえ: 次の質問へ
2. 年齢は10歳未満？ → はい: 生存の可能性高い / いいえ: 生存の可能性低い
決定木の構造
【決定木の例】
┌──────────┐
│特徴A < 5?│ ← ルートノード（最初の質問）
└──────────┘
/ \
Yes No
/ \
┌──────────┐ ┌──────────┐
│クラス0 │ │特徴B < 3?│ ← 内部ノード
└──────────┘ └──────────┘
↑ / \
葉ノード Yes No
/ \
┌──────────┐ ┌──────────┐
│クラス1 │ │クラス0 │ ← 葉ノード（結論）
└──────────┘ └──────────┘
【用語】
・ルートノード: 最初の分岐点
・内部ノード: 途中の分岐点
・葉ノード: 最終的な予測（クラス）
・深さ: ルートから葉までの質問の数
決定木の実装
from sklearn.tree import DecisionTreeClassifier, plot_tree
# 決定木モデル
dt = DecisionTreeClassifier(max_depth=3, random_state=42)
dt.fit(X_train, y_train)
y_pred_dt = dt.predict(X_test)
print(“=== 決定木の結果 ===”)
print(f”正解率: {accuracy_score(y_test, y_pred_dt):.4f}”)
# 特徴量の重要度
print(“\n=== 特徴量の重要度 ===”)
for i, importance in enumerate(dt.feature_importances_):
print(f”Feature {i+1}: {importance:.4f}”)
=== 決定木の結果 ===
正解率: 0.9333
=== 特徴量の重要度 ===
Feature 1: 0.5234
Feature 2: 0.4766
max_depthの影響
# 異なる深さで実験
depths = [2, 5, 10, None] # Noneは制限なし
print(“=== 深さによる性能の違い ===”)
for depth in depths:
dt_temp = DecisionTreeClassifier(max_depth=depth, random_state=42)
dt_temp.fit(X_train, y_train)
train_score = dt_temp.score(X_train, y_train)
test_score = dt_temp.score(X_test, y_test)
depth_str = str(depth) if depth is not None else ‘unlimited’
print(f”max_depth={depth_str:10s}: Train={train_score:.4f}, Test={test_score:.4f}”)
=== 深さによる性能の違い ===
max_depth=2 : Train=0.8929, Test=0.8833
max_depth=5 : Train=0.9571, Test=0.9333
max_depth=10 : Train=1.0000, Test=0.9167
max_depth=unlimited : Train=1.0000, Test=0.8833
⚠️ 過学習の兆候
max_depth=10やunlimitedでは：訓練精度 = 1.0（完璧）、テスト精度 < 0.93（訓練より低い）
→ 過学習しています！max_depth=5が最もバランスが良いです。
✅ 決定木の利点
- 非常に解釈しやすい：人間が理解できる「if-then」ルール
- 前処理不要：スケーリングや正規化が不要
- 非線形関係に対応：複雑なパターンを捉えられる
- 数値・カテゴリ両方扱える
- 特徴量の重要度がわかる
- 過学習しやすい：深い木はデータに過剰適応
- 不安定：データが少し変わると木の構造が大きく変わる
- 滑らかな決定境界が苦手
⚖️ 5. アルゴリズムの比較
3つのアルゴリズムを同じデータで比較
import pandas as pd
# すべてのモデルで評価
models = {
‘Logistic Regression’: LogisticRegression(random_state=42),
‘KNN (k=5)’: KNeighborsClassifier(n_neighbors=5),
‘Decision Tree’: DecisionTreeClassifier(max_depth=5, random_state=42)
}
results = []
for name, model in models.items():
model.fit(X_train, y_train)
train_score = model.score(X_train, y_train)
test_score = model.score(X_test, y_test)
results.append({
‘Model’: name,
‘Train Accuracy’: train_score,
‘Test Accuracy’: test_score,
‘Difference’: train_score – test_score
})
# 結果を表示
results_df = pd.DataFrame(results)
print(“=== モデルの性能比較 ===”)
print(results_df.to_string(index=False))
=== モデルの性能比較 ===
Model Train Accuracy Test Accuracy Difference
Logistic Regression 0.9500 0.9500 0.0000
KNN (k=5) 0.9429 0.9333 0.0096
Decision Tree 0.9571 0.9333 0.0238
💡 どのアルゴリズムを選ぶ？
| アルゴリズム | 向いている場合 | 避けるべき場合 |
|---|---|---|
| ロジスティック回帰 | ・線形分離可能 ・確率が必要 ・速度重視 ・解釈性重視 |
・複雑な非線形パターン ・特徴量間の相互作用が重要 |
| KNN | ・非線形パターン ・データが少ない ・多クラス分類 |
・データが多い（遅い） ・高次元データ ・予測速度重視 |
| 決定木 | ・解釈性が最重要 ・カテゴリ変数が多い ・前処理したくない |
・滑らかな決定境界 ・安定性重視 ・（単体では過学習しやすい） |
📧 6. 実践プロジェクト：テキスト分類
データの準備
from sklearn.datasets import fetch_20newsgroups
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.metrics import classification_report
# ニュースグループデータ（テキスト分類の標準データセット）
categories = [‘alt.atheism’, ‘soc.religion.christian’]
newsgroups = fetch_20newsgroups(
subset=’all’,
categories=categories,
remove=(‘headers’, ‘footers’, ‘quotes’),
random_state=42
)
print(“=== データセットの情報 ===”)
print(f”データ数: {len(newsgroups.data)}”)
print(f”クラス数: {len(newsgroups.target_names)}”)
print(f”クラス名: {newsgroups.target_names}”)
# テキストを数値ベクトルに変換
vectorizer = CountVectorizer(max_features=1000, stop_words=’english’)
X = vectorizer.fit_transform(newsgroups.data)
y = newsgroups.target
print(f”\n=== ベクトル化後 ===”)
print(f”特徴量数: {X.shape[1]}”)
print(f”データ数: {X.shape[0]}”)
# データ分割
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.3, random_state=42, stratify=y
)
=== データセットの情報 ===
データ数: 1427
クラス数: 2
クラス名: [‘alt.atheism’, ‘soc.religion.christian’]
=== ベクトル化後 ===
特徴量数: 1000
データ数: 1427
モデルの訓練と比較
# 3つのモデルで比較
models = {
‘Logistic Regression’: LogisticRegression(max_iter=1000, random_state=42),
‘KNN (k=5)’: KNeighborsClassifier(n_neighbors=5),
‘Decision Tree’: DecisionTreeClassifier(max_depth=10, random_state=42)
}
print(“=== テキスト分類の結果 ===\n”)
for name, model in models.items():
model.fit(X_train, y_train)
train_score = model.score(X_train, y_train)
test_score = model.score(X_test, y_test)
print(f”{name}: 訓練精度={train_score:.4f}, テスト精度={test_score:.4f}”)
=== テキスト分類の結果 ===
Logistic Regression: 訓練精度=0.9980, テスト精度=0.9301
KNN (k=5): 訓練精度=0.8910, テスト精度=0.7948
Decision Tree: 訓練精度=0.9940, テスト精度=0.7738
🔍 結果の分析
最良：ロジスティック回帰（93.01%）
理由：テキストデータは高次元で線形分離しやすい
KNN：79.48%
理由：高次元データで距離計算が不安定
決定木：77.38%
理由：過学習（訓練精度99.4% vs テスト精度77.4%）
📝 練習問題
問題1
やさしい
分類問題の種類
以下の問題を、二値分類・多クラス分類・多ラベル分類のいずれかに分類してください。
- メールがスパムか正常かを判定する
- 手書き数字（0〜9）を認識する
- 映画に複数のジャンル（アクション、コメディ、ホラー等）をタグ付けする
- 顧客が購入するかしないかを予測する
正解：
- 二値分類：スパム/正常の2クラス
- 多クラス分類：0〜9の10クラス
- 多ラベル分類：1つの映画に複数のジャンルを同時に付与
- 二値分類：購入する/しないの2クラス
問題2
やさしい
ロジスティック回帰の基本
ロジスティック回帰について、正しい説明をすべて選んでください。
- A. 名前に「回帰」とあるが、実際は分類アルゴリズムである
- B. 出力は0〜1の確率である
- C. 非線形な決定境界を描くことができる
- D. シグモイド関数を使用する
- E. 係数から特徴量の重要度を解釈できる
正解：A、B、D、E
各選択肢の解説：
- A（正解）：名前に反して分類アルゴリズムです。
- B（正解）：シグモイド関数により0〜1の確率を出力します。
- C（誤り）：ロジスティック回帰は線形な決定境界しか描けません。非線形には対応できません。
- D（正解）：シグモイド関数 p = 1/(1+e^(-z)) を使用します。
- E（正解）：係数の大きさから特徴量の影響を解釈できます。
問題3
やさしい
シグモイド関数の計算
シグモイド関数 σ(z) = 1/(1+e^(-z)) について、z=0のときの値を計算してください。
正解：0.5
計算：
σ(0) = 1 / (1 + e^(-0))
= 1 / (1 + e^0)
= 1 / (1 + 1)
= 1 / 2
= 0.5
z=0のとき、確率は0.5（50%）です。これは「どちらのクラスか決められない」中間状態を意味します。
問題4
ふつう
KNNのkの選択
KNNでk=1、k=5、k=100を使った場合、それぞれどのような特徴がありますか？過学習・過少適合の観点から説明してください。
解答
k=1：
- 最も近い1点だけで判断
- 決定境界が非常に複雑になる
- 過学習しやすい（ノイズに敏感）
- 訓練精度は高いが、テスト精度が低くなりがち
k=5：
- 近くの5点の多数決で判断
- ノイズの影響を軽減
- バランスが良い
- 多くの場合で最適な選択
k=100（または非常に大きいk）：
- 多くの点の多数決で判断
- 決定境界が非常に滑らかになる
- 過少適合しやすい（データの局所的な構造を無視）
- 極端な場合、全データの多数決になり、常に多い方のクラスを予測
問題5
ふつう
決定木のmax_depth
以下の決定木の結果から、最適なmax_depthを選び、その理由を説明してください。
max_depth=2: Train=0.85, Test=0.83
max_depth=5: Train=0.95, Test=0.92
max_depth=10: Train=1.00, Test=0.88
max_depth=20: Train=1.00, Test=0.82
正解：max_depth=5
理由：
- テスト精度が最も高い（0.92）
- 訓練精度とテスト精度の差が小さい（0.03）
- 過学習していない
各深さの分析：
- max_depth=2：過少適合（テスト精度が低い、改善の余地あり）
- max_depth=5：最適（テスト精度最高、バランス良好）
- max_depth=10：過学習の兆候（訓練1.00、テスト0.88、差=0.12）
- max_depth=20：明らかな過学習（訓練1.00、テスト0.82、差=0.18）
問題6
ふつう
アルゴリズムの選択
以下の状況で、最も適切なアルゴリズムを選んでください。
- 結果の解釈が最も重要（なぜその予測になったかを説明したい）
- データが100万件あり、予測速度が重要
- 特徴量が1000次元で、線形分離可能なデータ
- データが100件しかなく、非線形なパターンがある
正解：1. 決定木、2. ロジスティック回帰、3. ロジスティック回帰、4. KNN
各状況の解説：
- 1. 決定木：「if-then」ルールで説明でき、人間が理解しやすい。「年収 > 500万 かつ 年齢 > 30 なら購入」のように説明可能。
- 2. ロジスティック回帰：訓練が速く、予測も高速。KNNは予測時に全データとの距離計算が必要で遅い。決定木も速いが、ロジスティック回帰が最も軽量。
- 3. ロジスティック回帰：線形分離可能ならロジスティック回帰が最適。高次元でも効率的。KNNは高次元データで「次元の呪い」の影響を受ける。
- 4. KNN：データが少ない場合、KNNは訓練が不要（データを保存するだけ）で有効。非線形パターンにも対応できる。
問題7
むずかしい
KNNの実装
以下のコードを完成させて、最適なkを交差検証で見つけてください。
from sklearn.model_selection import cross_val_score
from sklearn.neighbors import KNeighborsClassifier
from sklearn.datasets import load_iris
# データ
iris = load_iris()
X, y = iris.data, iris.target
# k=1からk=20まで試す
k_range = range(1, 21)
scores = []
for k in k_range:
# TODO: KNNモデルを作成し、5分割交差検証でスコアを計算
pass
# 最適なkを見つける
# TODO: 最も高いスコアのkを見つける
解答
from sklearn.model_selection import cross_val_score
from sklearn.neighbors import KNeighborsClassifier
from sklearn.datasets import load_iris
import numpy as np
# データ
iris = load_iris()
X, y = iris.data, iris.target
# k=1からk=20まで試す
k_range = range(1, 21)
scores = []
for k in k_range:
knn = KNeighborsClassifier(n_neighbors=k)
cv_scores = cross_val_score(knn, X, y, cv=5, scoring=’accuracy’)
scores.append(cv_scores.mean())
# 最適なkを見つける
best_k = k_range[np.argmax(scores)]
best_score = max(scores)
print(“=== 交差検証の結果 ===”)
for k, score in zip(k_range, scores):
marker = ” ← Best” if k == best_k else “”
print(f”k={k:2d}: {score:.4f}{marker}”)
print(f”\n最適なk: {best_k}”)
print(f”最良スコア: {best_score:.4f}”)
=== 交差検証の結果 ===
k= 1: 0.9533
k= 2: 0.9467
k= 3: 0.9600
k= 4: 0.9667
k= 5: 0.9667
k= 6: 0.9733 ← Best
k= 7: 0.9667
k= 8: 0.9667
k= 9: 0.9733 ← Best
k=10: 0.9667
…
最適なk: 6
最良スコア: 0.9733
問題8
むずかしい
3つのアルゴリズムの比較
Irisデータセットで、ロジスティック回帰、KNN（k=5）、決定木（max_depth=3）を比較し、最も良いモデルを見つけてください。
解答
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score
# データ
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.3, random_state=42)
# モデル
models = {
‘Logistic Regression’: LogisticRegression(max_iter=200, random_state=42),
‘KNN (k=5)’: KNeighborsClassifier(n_neighbors=5),
‘Decision Tree (depth=3)’: DecisionTreeClassifier(max_depth=3, random_state=42)
}
# 評価
print(“=== Irisデータセットでの比較 ===”)
for name, model in models.items():
model.fit(X_train, y_train)
train_score = model.score(X_train, y_train)
test_score = model.score(X_test, y_test)
diff = train_score – test_score
print(f”{name:<30}: Train={train_score:.4f}, Test={test_score:.4f}, Diff={diff:.4f}")
=== Irisデータセットでの比較 ===
Logistic Regression : Train=0.9714, Test=1.0000, Diff=-0.0286
KNN (k=5) : Train=0.9619, Test=1.0000, Diff=-0.0381
Decision Tree (depth=3) : Train=0.9810, Test=0.9778, Diff=0.0032
結果の分析：
- ロジスティック回帰とKNN：テスト精度100%（このデータセットでは完璧に分類）
- 決定木：テスト精度97.78%（少し低いが、過学習していない）
- 推奨：ロジスティック回帰（速度、解釈性、精度のバランス）
注：Irisは小さく簡単なデータセットなので、ほとんどのアルゴリズムで高精度が出ます。実際のデータではもっと差が出ます。
📝 STEP 13 のまとめ
✅ このステップで学んだこと
- 分類問題：カテゴリを予測する問題
- ロジスティック回帰：確率を出力、線形決定境界
- KNN：近くのデータの多数決、非線形対応
- 決定木：質問で分類、解釈しやすい
- 各アルゴリズムの使い分け
- 実践的なテキスト分類プロジェクト
🚀 次のステップへ
次のSTEP 14では、アンサンブル学習の基礎を学びます。
アンサンブル学習とは：複数のモデルを組み合わせて、より強力なモデルを作る手法
学ぶ内容：バギング（Bagging）、ランダムフォレスト、ブースティング（Boosting）の基礎
❓ よくある質問
Q1. ロジスティック回帰と線形回帰の違いは？
目的の違い：
・線形回帰：連続値（数値）を予測（例：価格、温度）
・ロジスティック回帰：カテゴリを予測（例：スパム/正常）
出力の違い：
・線形回帰：任意の実数（-∞〜+∞）
・ロジスティック回帰：0〜1の確率
・線形回帰：連続値（数値）を予測（例：価格、温度）
・ロジスティック回帰：カテゴリを予測（例：スパム/正常）
出力の違い：
・線形回帰：任意の実数（-∞〜+∞）
・ロジスティック回帰：0〜1の確率
Q2. KNNでスケーリングは必要ですか？
Yes！必須です。
KNNは距離を計算するため、特徴量のスケールが異なると問題が生じます。
例：年齢（0〜100）と年収（0〜1000万）
→ 年収の差が距離を支配し、年齢はほとんど無視される
対策：StandardScalerやMinMaxScalerで標準化してから使う。
KNNは距離を計算するため、特徴量のスケールが異なると問題が生じます。
例：年齢（0〜100）と年収（0〜1000万）
→ 年収の差が距離を支配し、年齢はほとんど無視される
対策：StandardScalerやMinMaxScalerで標準化してから使う。
Q3. 決定木の「ジニ不純度」とは？
決定木が分岐を決める基準の一つです。
ジニ不純度 = 1 – Σ(pᵢ)²
（pᵢは各クラスの割合）
・0に近い：純度が高い（1つのクラスが支配的）
・0.5に近い：不純度が高い（クラスが混在）
決定木は、分岐後のジニ不純度が最も下がる分岐点を選びます。
ジニ不純度 = 1 – Σ(pᵢ)²
（pᵢは各クラスの割合）
・0に近い：純度が高い（1つのクラスが支配的）
・0.5に近い：不純度が高い（クラスが混在）
決定木は、分岐後のジニ不純度が最も下がる分岐点を選びます。
Q4. どのアルゴリズムを最初に試すべき？
一般的なおすすめ：
1. まずロジスティック回帰を試す（ベースライン）
2. 性能が不十分なら、ランダムフォレストを試す（次のSTEPで学習）
3. 解釈性が重要なら決定木
理由：
・ロジスティック回帰は高速で、多くの問題で良い性能
・ベースラインとして比較に使いやすい
1. まずロジスティック回帰を試す（ベースライン）
2. 性能が不十分なら、ランダムフォレストを試す（次のSTEPで学習）
3. 解釈性が重要なら決定木
理由：
・ロジスティック回帰は高速で、多くの問題で良い性能
・ベースラインとして比較に使いやすい
Q5. 多クラス分類でも同じアルゴリズムが使えますか？
Yes！すべて多クラス分類に対応しています。
・ロジスティック回帰：内部でOne-vs-Rest（OvR）またはSoftmaxを使用
・KNN：多数決なので自然に対応
・決定木：葉ノードで最も多いクラスを予測
scikit-learnでは、同じコードで二値分類も多クラス分類も扱えます。
・ロジスティック回帰：内部でOne-vs-Rest（OvR）またはSoftmaxを使用
・KNN：多数決なので自然に対応
・決定木：葉ノードで最も多いクラスを予測
scikit-learnでは、同じコードで二値分類も多クラス分類も扱えます。
学習メモ
機械学習入門 - Step 13
📋 過去のメモ一覧
▼