監督式學習

1.1.1. 分類(Classification)

1.1.2. 迴歸(Regression)

1.2.1. 信用卡詐欺

1.2.2. 影像辨識

1.2.3. 學測成績

2.2.1. K-nearest neighbors (KNN)

 1: from sklearn.datasets import load_iris
 2: from sklearn.model_selection import train_test_split
 3: from sklearn.neighbors import KNeighborsClassifier
 4: from sklearn.metrics import accuracy_score
 5: 
 6: X, y = load_iris(return_X_y=True)
 7: X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
 8: 
 9: # 建立 KNN 模型（k=5）
10: knn = KNeighborsClassifier(n_neighbors=5)
11: knn.fit(X_train, y_train)
12: 
13: # 預測與評估
14: y_pred = knn.predict(X_test)
15: print(f"KNN (k=5) 準確率: {accuracy_score(y_test, y_pred):.4f}")
16: 
17: # 觀察不同 k 值對準確率的影響
18: for k in [1, 3, 5, 7, 9]:
19:     knn = KNeighborsClassifier(n_neighbors=k)
20:     knn.fit(X_train, y_train)
21:     score = knn.score(X_test, y_test)
22:     print(f"  k={k}: {score:.4f}")

2.2.2. 決策樹與隨機森林（Decision Tree and Random Forest）

1. 決策樹（Decision Tree）
   

   決策樹透過一連串的「是/否」問題將資料逐步分割，最終達成分類或迴歸預測。其核心問題在於：每一步該選哪個特徵、用什麼條件來分割？這就需要「分裂準則」。

   1. 分裂準則
      
      • *熵（Entropy）*：衡量資料的混亂程度（不確定性）。若一組資料全部屬於同一類別，熵為 0（最純）；若各類別各佔一半，熵最大。 \[H(S) = -\sum_{i=1}^{c} p_i \log_2 p_i\] 其中 \(p_i\) 為第 \(i\) 類別在資料集 \(S\) 中的比例，\(c\) 為類別數。
      • *資訊增益（Information Gain）*：分割前後熵的減少量。決策樹會選擇資訊增益最大的特徵進行分割。 \[IG(S, A) = H(S) - \sum_{v \in \text{values}(A)} \frac{|S_v|}{|S|} H(S_v)\]
      • *吉尼不純度（Gini Impurity）*：另一種衡量混亂程度的指標，計算更快。scikit-learn 的決策樹預設使用 Gini。 \[Gini(S) = 1 - \sum_{i=1}^{c} p_i^2\]

      決策樹的特點：

      • 優點：直觀易懂、結果可解釋（可視覺化為樹狀圖）、不需特徵縮放
      • 缺點：容易過度擬合（overfitting），尤其是樹的深度不加限制時

       1: from sklearn.datasets import load_iris
       2: from sklearn.model_selection import train_test_split
       3: from sklearn.tree import DecisionTreeClassifier, export_text
       4: from sklearn.metrics import accuracy_score
       5: 
       6: X, y = load_iris(return_X_y=True)
       7: feature_names = load_iris().feature_names
       8: X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
       9: 
      10: # 建立決策樹（限制深度為 3，避免過度擬合）
      11: dt = DecisionTreeClassifier(max_depth=3, random_state=42)
      12: dt.fit(X_train, y_train)
      13: 
      14: y_pred = dt.predict(X_test)
      15: print(f"Decision Tree 準確率: {accuracy_score(y_test, y_pred):.4f}")
      16: 
      17: # 印出決策樹的規則（可解釋性高）
      18: print("\n決策樹規則:")
      19: print(export_text(dt, feature_names=feature_names))
      

2. Bagging 與隨機森林
   
   • *Bagging*（Bootstrap Aggregation）：使用多次隨機抽樣（有放回抽樣）建立多棵 decision tree，再透過平均（迴歸）或多數決（分類）彙整預測結果，藉此降低過度擬合。
   • *Random Forest*：在 Bagging 的基礎上，每棵樹的每次分裂只從隨機挑選的部分特徵中選擇最佳分裂條件（而非使用所有特徵）。這使得各棵樹之間相關性更低，進一步改善泛化能力。
     • 優點：準確度高、不易過度擬合、能評估特徵重要性
     • 缺點：可解釋性較單棵決策樹低、訓練時間較長

    1: from sklearn.datasets import load_iris
    2: from sklearn.model_selection import train_test_split
    3: from sklearn.ensemble import RandomForestClassifier
    4: from sklearn.metrics import accuracy_score
    5: 
    6: X, y = load_iris(return_X_y=True)
    7: feature_names = load_iris().feature_names
    8: X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
    9: 
   10: # 建立 Random Forest（100 棵樹）
   11: rf = RandomForestClassifier(n_estimators=100, random_state=42)
   12: rf.fit(X_train, y_train)
   13: 
   14: y_pred = rf.predict(X_test)
   15: print(f"Random Forest 準確率: {accuracy_score(y_test, y_pred):.4f}")
   16: 
   17: # 顯示各特徵的重要性排名
   18: print("\n特徵重要性:")
   19: for name, imp in sorted(zip(feature_names, rf.feature_importances_),
   20:                          key=lambda x: x[1], reverse=True):
   21:     print(f"  {name}: {imp:.4f}")
   

2.2.3. Boosting

 1: from sklearn.datasets import load_iris
 2: from sklearn.model_selection import train_test_split
 3: from sklearn.ensemble import GradientBoostingClassifier
 4: from sklearn.metrics import accuracy_score
 5: 
 6: X, y = load_iris(return_X_y=True)
 7: X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
 8: 
 9: # 建立 Gradient Boosting 模型
10: gb = GradientBoostingClassifier(
11:     n_estimators=100,    # 樹的數量
12:     learning_rate=0.1,   # 學習率（每棵樹的貢獻度）
13:     max_depth=3,         # 每棵樹的最大深度
14:     random_state=42
15: )
16: gb.fit(X_train, y_train)
17: 
18: y_pred = gb.predict(X_test)
19: print(f"Gradient Boosting 準確率: {accuracy_score(y_test, y_pred):.4f}")
20: 
21: # 觀察隨著樹的數量增加，訓練與測試準確率的變化
22: import numpy as np
23: train_scores = []
24: test_scores = []
25: for i, y_pred_train in enumerate(gb.staged_predict(X_train)):
26:     train_scores.append(accuracy_score(y_train, y_pred_train))
27: for i, y_pred_test in enumerate(gb.staged_predict(X_test)):
28:     test_scores.append(accuracy_score(y_test, y_pred_test))
29: print(f"第 10 棵樹時測試準確率: {test_scores[9]:.4f}")
30: print(f"第 50 棵樹時測試準確率: {test_scores[49]:.4f}")
31: print(f"第 100 棵樹時測試準確率: {test_scores[99]:.4f}")

2.2.4. SVM（Support Vector Machines）

1. 核心概念
   
   • *超平面（Hyperplane）*：在 n 維空間中，超平面是一個 n-1 維的分隔面。二維空間中就是一條線，三維空間中就是一個平面。
   • *支援向量（Support Vectors）*：距離超平面最近的那些資料點，它們「支撐」住了超平面的位置。改變其他資料點不會影響超平面，但移動支援向量就會。
   • *間距（Margin）*：超平面到最近支援向量的距離。SVM 的目標就是找到 margin 最大的超平面，因為 margin 越大，模型的泛化能力越好。
2. Kernel Trick
   

   當資料在原始空間中無法被一個超平面線性分開時，SVM 可以透過 核函數（Kernel Function） 將資料映射到更高維的空間，使原本不可線性分割的資料變得可分割。常用的核函數包括：

   核函數	說明
   線性核（Linear）	適用於線性可分的資料
   多項式核（Polynomial）	適用於中等複雜度的非線性邊界
   RBF（高斯核）	最常用，適用於大多數非線性問題

   • 優點：在高維空間表現良好、有堅實的數學理論基礎、不易過度擬合（尤其資料量不大時）
   • 缺點：資料量大時訓練速度慢、對特徵縮放敏感、結果較難解釋

    1: from sklearn.datasets import load_iris
    2: from sklearn.model_selection import train_test_split
    3: from sklearn.svm import SVC
    4: from sklearn.preprocessing import StandardScaler
    5: from sklearn.metrics import accuracy_score
    6: 
    7: X, y = load_iris(return_X_y=True)
    8: X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
    9: 
   10: # SVM 對特徵縮放敏感，先做標準化
   11: scaler = StandardScaler()
   12: X_train_scaled = scaler.fit_transform(X_train)
   13: X_test_scaled = scaler.transform(X_test)
   14: 
   15: # 比較不同核函數的效果
   16: for kernel in ['linear', 'poly', 'rbf']:
   17:     svm = SVC(kernel=kernel, random_state=42)
   18:     svm.fit(X_train_scaled, y_train)
   19:     score = svm.score(X_test_scaled, y_test)
   20:     print(f"SVM ({kernel:>6} kernel) 準確率: {score:.4f}")
   

2.2.5. 神經網路

 1: from sklearn.datasets import load_iris
 2: from sklearn.model_selection import train_test_split
 3: from sklearn.neural_network import MLPClassifier
 4: from sklearn.preprocessing import StandardScaler
 5: from sklearn.metrics import accuracy_score
 6: 
 7: X, y = load_iris(return_X_y=True)
 8: X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
 9: 
10: # 神經網路同樣需要特徵標準化
11: scaler = StandardScaler()
12: X_train_scaled = scaler.fit_transform(X_train)
13: X_test_scaled = scaler.transform(X_test)
14: 
15: # 建立兩層隱藏層（各 10 個神經元）的神經網路
16: mlp = MLPClassifier(hidden_layer_sizes=(10, 10), max_iter=1000, random_state=42)
17: mlp.fit(X_train_scaled, y_train)
18: 
19: y_pred = mlp.predict(X_test_scaled)
20: print(f"Neural Network 準確率: {accuracy_score(y_test, y_pred):.4f}")
21: print(f"網路結構: 輸入層({X_train.shape[1]}) → 隱藏層(10) → 隱藏層(10) → 輸出層({len(set(y))})")
22: print(f"訓練迭代次數: {mlp.n_iter_}")

3.1.1. 混淆矩陣（Confusion Matrix）

3.1.2. 常用指標

3.1.3. ROC 曲線與 AUC