reveal.js

# การเปรียบเทียบวิธีการเรียนรู้แบบพาราเมตริกและไม่ใช่พาราเมตริก
## Parametric vs Non-Parametric Learning

**ผู้จัดทำ:** อรรถพล คงหวาน

---

## Outline

1. บทนำ
2. Parametric Models
3. Non-Parametric Models
4. Decision Trees
5. Ensemble Methods
6. การเปรียบเทียบและการเลือกใช้งาน
7. สรุป

---

# 1. บทนำ

---

## 1.1 ความสำคัญของการจำแนกประเภทโมเดล

- การเลือกโมเดลที่เหมาะสมกับลักษณะข้อมูลเป็นสิ่งสำคัญ
- **การจำแนกโมเดล:**
  - **Parametric** - จำนวนพารามิเตอร์คงที่
  - **Non-Parametric** - พารามิเตอร์เพิ่มตามข้อมูล
- ช่วยให้เข้าใจคุณลักษณะพื้นฐานของอัลกอริทึม

---

## 1.2 ภาพรวมความแตกต่าง

subgraph param["Parametric Models"]
        P1["จำนวนพารามิเตอร์คงที่"]
        P2["สมมติฐานชัดเจน"]
        P3["เรียนรู้เร็ว"]
    end

subgraph nonparam["Non-Parametric Models"]
        N1["พารามิเตอร์เพิ่มตามข้อมูล"]
        N2["สมมติฐานน้อย"]
        N3["ยืดหยุ่นสูง"]
    end

ML --> param
    ML --> nonparam
```

---

## 1.3 ประวัติศาสตร์และพัฒนาการ (1)

**ยุคบุกเบิก (1950s-1960s)**
- 1956: Perceptron - Frank Rosenblatt
- 1957: k-NN Algorithm - Fix & Hodges

**ยุคพัฒนา (1970s-1980s)**
- 1979: CART - Breiman et al.
- 1984: ID3 Algorithm - Quinlan
- 1986: Backpropagation - Rumelhart

---

## 1.3 ประวัติศาสตร์และพัฒนาการ (2)

**ยุคทอง (1990s-2000s)**
- 1995: Random Forest - Ho, Breiman
- 1996: Bagging - Breiman
- 1999: Gradient Boosting - Friedman

**ยุคปัจจุบัน (2010s+)**
- XGBoost, LightGBM, CatBoost
- Deep Learning Integration

---

# 2. Parametric Models

---

## 2.1 นิยามและแนวคิดพื้นฐาน

**Parametric Model** คือโมเดลที่มีจำนวนพารามิเตอร์คงที่

**คุณลักษณะสำคัญ:**
- จำนวนพารามิเตอร์ถูกกำหนดไว้ก่อนการเรียนรู้
- ตั้งสมมติฐานเกี่ยวกับ Data Distribution
- หลังฝึกสอน ไม่ต้องเก็บข้อมูลฝึกสอนไว้
- ความซับซ้อนไม่เพิ่มขึ้นตามขนาดข้อมูล

---

## 2.2 ตัวอย่างโมเดลพาราเมตริก

```mermaid
%%{init: {'theme': 'base', 'themeVariables': { 'primaryColor': '#458588', 'primaryTextColor': '#ebdbb2', 'primaryBorderColor': '#83a598', 'lineColor': '#ebdbb2', 'secondaryColor': '#d65d0e', 'tertiaryColor': '#282828', 'background': '#282828'}}}%%
flowchart TB
 subgraph parametric["Parametric Models"]
 LR["Linear Regression y = wx + b"]
 LOG["Logistic Regression σ(wx + b)"]
 NB["Naive Bayes P(x|C)"]
 LDA["Linear Discriminant Analysis"]
 NN["Neural Networks"]
 end
```

---

## 2.3.1 Linear Regression - สมการโมเดล

**ตัวแปร:** y = ค่าทำนาย, w₀ = Intercept, wᵢ = Weight, xᵢ = Feature

---

## 2.3.1 Linear Regression - Cost Function

**Mean Squared Error:**

**ตัวแปร:** J(w) = Cost Function, m = จำนวนตัวอย่าง

---

## 2.3.2 Logistic Regression

**ตัวแปร:** P(y=1|x) = ความน่าจะเป็น, σ(·) = Sigmoid, e ≈ 2.71828

---

## 2.4 ตัวอย่างการคำนวณ - ข้อมูล

**โจทย์:** พื้นที่บ้าน (ตร.ม.) → ราคา (ล้านบาท)

| พื้นที่ (x) | ราคา (y) |
|------------|----------|
| 50 | 2.0 |
| 80 | 3.2 |
| 100 | 4.0 |
| 120 | 4.8 |

---

## 2.4 ตัวอย่างการคำนวณ - ขั้นตอน

**1. คำนวณค่าเฉลี่ย:** x̄ = 87.5, ȳ = 3.5

**2. คำนวณ w₁ (slope):**

---

## 2.4 ตัวอย่างการคำนวณ - ผลลัพธ์

**3. คำนวณ w₀ (intercept):**
- w₀ = ȳ - w₁·x̄ = 3.5 - (0.04)(87.5) = **0**

**4. สมการที่ได้:** y = 0.04x + 0

**5. ทำนายราคาบ้านพื้นที่ 90 ตร.ม.:**
- y = 0.04 × 90 = **3.6 ล้านบาท**

---

## 2.5 ตัวอย่างโค้ด Python (1)

```python
class LinearRegressionParametric:
    def __init__(self, learning_rate=0.01, n_iterations=1000):
        self.learning_rate = learning_rate
        self.n_iterations = n_iterations
        self.weights = None  # พารามิเตอร์ w
        self.bias = None     # พารามิเตอร์ b
```

**จุดสำคัญ:** จำนวนพารามิเตอร์คงที่ (weights + bias)

---

## 2.5 ตัวอย่างโค้ด Python (2)

```python
def fit(self, X, y):
    n_samples, n_features = X.shape
    self.weights = np.zeros(n_features)
    self.bias = 0

for _ in range(self.n_iterations):
        y_pred = np.dot(X, self.weights) + self.bias
        dw = (1/n_samples) * np.dot(X.T, (y_pred - y))
        db = (1/n_samples) * np.sum(y_pred - y)
        self.weights -= self.learning_rate * dw
        self.bias -= self.learning_rate * db
```

---

## 2.5 ตัวอย่างโค้ด Python (3)

```python
def predict(self, X):
    # ไม่ต้องใช้ข้อมูลฝึกสอน
    # ใช้เพียงพารามิเตอร์ที่เรียนรู้มา
    return np.dot(X, self.weights) + self.bias

def get_params_count(self):
    # จำนวนพารามิเตอร์คงที่
    return len(self.weights) + 1
```

---

## 2.5 ผลลัพธ์การรันโค้ด

```
พารามิเตอร์ที่เรียนรู้:
  - Weight (w): 0.0400
  - Bias (b): 0.0000
  - จำนวนพารามิเตอร์ทั้งหมด: 2

การทำนาย:
  - พื้นที่ 90 ตร.ม. -> ราคา 3.60 ล้านบาท
  - พื้นที่ 150 ตร.ม. -> ราคา 6.00 ล้านบาท

📌 จำนวนพารามิเตอร์ = 2
   (คงที่ไม่ว่าจะมีข้อมูล 4 หรือ 4000 ตัวอย่าง)
```

---

## 2.6 ข้อดีและข้อจำกัด

| ด้าน | ข้อดี | ข้อจำกัด |
|------|-------|----------|
| **ความเร็ว** | ฝึกสอนและทำนายเร็ว | อาจไม่จับ pattern ซับซ้อน |
| **หน่วยความจำ** | ใช้น้อย | ต้องเลือกรูปแบบโมเดลถูกต้อง |
| **การตีความ** | อธิบายได้ง่าย | อาจ underfit ถ้าสมมติฐานผิด |
| **ข้อมูลน้อย** | ทำงานได้ดี | ไม่ยืดหยุ่นกับ pattern ใหม่ |

---

# 3. Non-Parametric Models

---

## 3.1 นิยามและแนวคิดพื้นฐาน

**Non-Parametric Model** คือโมเดลที่ไม่กำหนดจำนวนพารามิเตอร์ล่วงหน้า

**คุณลักษณะสำคัญ:**
- จำนวนพารามิเตอร์เพิ่มขึ้นตามจำนวนข้อมูล
- ไม่ตั้งสมมติฐานเกี่ยวกับรูปแบบฟังก์ชัน
- ต้องเก็บข้อมูลฝึกสอนไว้
- ยืดหยุ่นสูงในการจับ pattern ซับซ้อน

---

## 3.2 k-Nearest Neighbors (k-NN)

```mermaid
%%{init: {'theme': 'base', 'themeVariables': { 'primaryColor': '#458588', 'primaryTextColor': '#ebdbb2', 'primaryBorderColor': '#83a598', 'lineColor': '#ebdbb2', 'secondaryColor': '#d65d0e', 'tertiaryColor': '#282828', 'background': '#282828'}}}%%
flowchart LR
    INPUT["ข้อมูลใหม่"]
    S1["1 คำนวณระยะห่าง"]
    S2["2 เลือก k เพื่อนบ้าน"]
    S3["3 รวมผลลัพธ์"]
    OUT["ผลลัพธ์"]

INPUT --> S1 --> S2 --> S3 --> OUT
```

---

## 3.2.2 สมการระยะทาง - Euclidean

---

## 3.2.2 สมการระยะทาง - Manhattan

---

## 3.2.2 สมการระยะทาง - Minkowski

**หมายเหตุ:** p=1 → Manhattan, p=2 → Euclidean

---

## 3.2.3 ตัวอย่าง k-NN - ข้อมูล

**โจทย์:** จำแนกผลไม้จากน้ำหนักและความหวาน

| ผลไม้ | น้ำหนัก (g) | ความหวาน (Brix) | ประเภท |
|-------|-------------|-----------------|--------|
| A | 150 | 12 | แอปเปิ้ล |
| B | 170 | 14 | แอปเปิ้ล |
| C | 100 | 18 | ส้ม |
| D | 120 | 16 | ส้ม |
| E | 80 | 20 | ส้ม |

**ผลไม้ใหม่:** น้ำหนัก = 130, ความหวาน = 15, k = 3

---

## 3.2.3 ตัวอย่าง k-NN - คำนวณระยะห่าง

**คำนวณระยะห่าง (Euclidean):**
- d(new, A) = √[(130-150)² + (15-12)²] = √409 = **20.22**
- d(new, B) = √[(130-170)² + (15-14)²] = √1601 = **40.01**
- d(new, C) = √[(130-100)² + (15-18)²] = √909 = **30.15**
- d(new, D) = √[(130-120)² + (15-16)²] = √101 = **10.05**
- d(new, E) = √[(130-80)² + (15-20)²] = √2525 = **50.25**

---

## 3.2.3 ตัวอย่าง k-NN - ผลลัพธ์

**เลือก k=3 เพื่อนบ้าน:**
1. D: 10.05 (ส้ม)
2. A: 20.22 (แอปเปิ้ล)
3. C: 30.15 (ส้ม)

**Majority Voting:**
- ส้ม: 2 เสียง
- แอปเปิ้ล: 1 เสียง

**ผลลัพธ์:** ผลไม้ใหม่ถูกจำแนกเป็น **ส้ม**

---

## 3.3 Kernel Regression

**Nadaraya-Watson Estimator:**

**ตัวแปร:** K(·) = Kernel Function, h = Bandwidth

---

## 3.3.2 ประเภท Kernel Functions

**Gaussian Kernel:**

**ประเภทอื่นๆ:**
- Epanechnikov: K(u) = ¾(1-u²) if |u| ≤ 1
- Uniform: K(u) = ½ if |u| ≤ 1
- Triangular: K(u) = (1-|u|) if |u| ≤ 1

---

## 3.4 ตัวอย่างโค้ด k-NN (1)

```python
class KNNClassifier:
    def __init__(self, k=3):
        self.k = k
        self.X_train = None  # ต้องเก็บข้อมูลไว้
        self.y_train = None

def fit(self, X, y):
        # k-NN เป็น Lazy Learner
        # แค่เก็บข้อมูลไว้ใช้ตอนทำนาย
        self.X_train = X.copy()
        self.y_train = y.copy()
```

---

## 3.4 ตัวอย่างโค้ด k-NN (2)

```python
def predict(self, X):
    predictions = []
    for x in X:
        # เปรียบเทียบกับข้อมูลฝึกสอนทุกจุด
        distances = [self._euclidean_distance(x, x_train)
                    for x_train in self.X_train]
        k_indices = np.argsort(distances)[:self.k]
        k_labels = self.y_train[k_indices]
        # Majority Voting
        most_common = Counter(k_labels).most_common(1)
        predictions.append(most_common[0][0])
    return np.array(predictions)
```

---

## 3.4 Memory Usage ตามขนาดข้อมูล

```
📊 Memory Usage:
   n=   10:      60 ค่า
   n=  100:     600 ค่า
   n= 1000:    6000 ค่า
   n=10000:   60000 ค่า
```

**ข้อสังเกต:** จำนวนค่าที่ต้องเก็บเพิ่มขึ้นตามจำนวนข้อมูล

---

## 3.5 ข้อดีและข้อจำกัด

| ด้าน | ข้อดี | ข้อจำกัด |
|------|-------|----------|
| **ความยืดหยุ่น** | จับ pattern ซับซ้อนได้ | อาจ overfit ถ้าข้อมูลน้อย |
| **สมมติฐาน** | ไม่ต้องสมมติรูปแบบ | ต้องเลือก hyperparameter (k, h) |
| **หน่วยความจำ** | - | ใช้มากเมื่อข้อมูลใหญ่ |
| **ความเร็ว** | ไม่ต้อง train | ช้าตอนทำนาย |

---

# 4. Decision Trees

---

## 4.1 นิยามและแนวคิดพื้นฐาน

**Decision Tree** เป็นโมเดล **Semi-Parametric**
- โครงสร้างซับซ้อนขึ้นตามข้อมูล
- มี hyperparameters เช่น ความลึกสูงสุด

**หลักการ:** แบ่งข้อมูลเป็นส่วนย่อยโดยใช้คำถาม yes/no ต่อเนื่องกัน

---

## 4.2 โครงสร้างต้นไม้ตัดสินใจ

```mermaid
%%{init: {'theme': 'base', 'themeVariables': { 'primaryColor': '#458588', 'primaryTextColor': '#ebdbb2', 'primaryBorderColor': '#83a598', 'lineColor': '#ebdbb2', 'secondaryColor': '#d65d0e', 'tertiaryColor': '#282828', 'background': '#282828'}}}%%
flowchart TB
 ROOT["🌳 Root Node อายุ ≤ 30?"]
 L1["Internal Node รายได้ ≤ 50k?"]
 R1["Leaf 🍃 ไม่ซื้อ"]
 L2["Leaf 🍃 ซื้อ"]
 R2["Internal เครดิต ดี?"]
 L3["Leaf 🍃 ซื้อ"]
 R3["Leaf 🍃 ไม่ซื้อ"]

ROOT -->|Yes| L1
    ROOT -->|No| R1
    L1 -->|Yes| L2
    L1 -->|No| R2
    R2 -->|Yes| L3
    R2 -->|No| R3
```

---

## 4.3.1 Entropy

**Entropy (ความไม่แน่นอน):**

**ตัวแปร:** H(S) = Entropy, c = จำนวน classes, pᵢ = สัดส่วน class i

---

## 4.3.1 Information Gain

<math xmlns="http://www.w3.org/1998/Math/MathML" display="block">
 <mrow>
 <mi>IG</mi><mo>(</mo><mi>S</mi><mo>,</mo><mi>A</mi><mo>)</mo>
 <mo>=</mo>
 <mi>H</mi><mo>(</mo><mi>S</mi><mo>)</mo>
 <mo>-</mo>
 <munderover><mo>∑</mo><mrow><mi>v</mi><mo>∈</mo><mi>Values</mi><mo>(</mo><mi>A</mi><mo>)</mo></mrow><mrow></mrow></munderover>
 <mfrac><mrow><mo>|</mo><msub><mi>S</mi><mi>v</mi></msub><mo>|</mo></mrow><mrow><mo>|</mo><mi>S</mi><mo>|</mo></mrow></mfrac>
 <mi>H</mi><mo>(</mo><msub><mi>S</mi><mi>v</mi></msub><mo>)</mo>
 </mrow>
</math>

**ตัวแปร:** IG = Information Gain, A = attribute, Sᵥ = ชุดย่อย

---

## 4.3.2 Gini Impurity

**ตัวแปร:** Gini(S) = Gini Impurity, pᵢ = สัดส่วน class i

---

## 4.4 ตัวอย่างการคำนวณ - ข้อมูล

**โจทย์:** ข้อมูลลูกค้าซื้อ/ไม่ซื้อสินค้า

| อายุ | รายได้ | ซื้อ | จำนวน |
|------|--------|------|-------|
| หนุ่ม | สูง/ปานกลาง/ต่ำ | ไม่/ไม่/ซื้อ/ไม่ | 4 |
| กลาง | สูง/ต่ำ | ซื้อ/ซื้อ | 2 |
| แก่ | ปานกลาง/ต่ำ | ซื้อ/ซื้อ/ไม่/ซื้อ | 4 |

**รวม:** ซื้อ 6, ไม่ซื้อ 4

---

## 4.4 ตัวอย่างการคำนวณ - Entropy

**คำนวณ Entropy ของชุดข้อมูลทั้งหมด:**

- ซื้อ: 6 ตัวอย่าง (p₁ = 0.6)
- ไม่ซื้อ: 4 ตัวอย่าง (p₂ = 0.4)

H(S) = -0.6 × log₂(0.6) - 0.4 × log₂(0.4)
     = 0.442 + 0.529 = **0.971 bits**

---

## 4.4 ตัวอย่างการคำนวณ - Information Gain

**คำนวณ IG สำหรับ "อายุ":**

| อายุ | Entropy |
|------|---------|
| หนุ่ม | 0.811 |
| กลาง | 0 (pure) |
| แก่ | 0.811 |

H(S|อายุ) = (4/10)×0.811 + 0 + (4/10)×0.811 = 0.649

**IG(อายุ) = 0.971 - 0.649 = 0.322 bits**

---

## 4.5 ตัวอย่างโค้ด Decision Tree (1)

```python
class DecisionTreeNode:
    def __init__(self, feature_index=None, threshold=None,
                 left=None, right=None, value=None):
        self.feature_index = feature_index
        self.threshold = threshold
        self.left = left      # ≤ threshold
        self.right = right    # > threshold
        self.value = value    # สำหรับ leaf node
```

---

## 4.5 ตัวอย่างโค้ด Decision Tree (2)

```python
def _entropy(self, y):
    if len(y) == 0:
        return 0
    counter = Counter(y)
    probabilities = [count/len(y) for count in counter.values()]
    entropy = 0
    for p in probabilities:
        if p > 0:
            entropy -= p * np.log2(p)
    return entropy
```

---

## 4.5 ตัวอย่างโค้ด Decision Tree (3)

```python
def _information_gain(self, y, y_left, y_right):
    n = len(y)
    n_left, n_right = len(y_left), len(y_right)

if n_left == 0 or n_right == 0:
        return 0

parent_entropy = self._entropy(y)
    child_entropy = (n_left/n) * self._entropy(y_left) + \
                    (n_right/n) * self._entropy(y_right)

return parent_entropy - child_entropy
```

---

## 4.5 ผลลัพธ์การรันโค้ด

```
📊 ข้อมูลต้นไม้:
   - จำนวนโหนด: 7
   - ความลึกสูงสุด: 3

📌 การทำนาย:
   อายุ: หนุ่ม, รายได้: สูง -> ไม่ซื้อ
   อายุ: กลาง, รายได้: ปานกลาง -> ซื้อ
   อายุ: แก่, รายได้: สูง -> ซื้อ

📊 จำนวนโหนดตามความลึก:
   max_depth= 1:   3 โหนด
   max_depth= 5:  15 โหนด
   max_depth=10:  23 โหนด
```

---

# 5. Ensemble Methods

---

## 5.1 แนวคิดพื้นฐาน

**Ensemble Methods** คือเทคนิคที่รวมโมเดลหลายตัวเข้าด้วยกัน

**หลักการ:** "ความคิดเห็นของกลุ่มมักดีกว่าความคิดเห็นของคนเดียว"

**ประเภท:**
- **Bagging** - สุ่มข้อมูล, สร้างโมเดลขนาน
- **Boosting** - สร้างโมเดลตามลำดับ, เน้นตัวที่ผิด
- **Stacking** - ใช้ Meta-learner เรียนรู้วิธีรวม

---

## 5.2 Bagging Process

```mermaid
%%{init: {'theme': 'base', 'themeVariables': { 'primaryColor': '#458588', 'primaryTextColor': '#ebdbb2', 'primaryBorderColor': '#83a598', 'lineColor': '#ebdbb2', 'secondaryColor': '#d65d0e', 'tertiaryColor': '#282828', 'background': '#282828'}}}%%
flowchart TB
 DATA["Original Dataset"]
 BS1["Bootstrap Sample 1"]
 BS2["Bootstrap Sample 2"]
 BSK["Bootstrap Sample k"]
 M1["Model 1"]
 M2["Model 2"]
 MK["Model k"]
 AGG["Aggregation Vote/Average"]
 FINAL["Final Prediction"]

DATA --> BS1 & BS2 & BSK
    BS1 --> M1
    BS2 --> M2
    BSK --> MK
    M1 & M2 & MK --> AGG --> FINAL
```

---

## 5.2.2 สูตรการทำนาย - Classification

**Majority Voting:**

---

## 5.2.2 สูตรการทำนาย - Regression

**Averaging:**

**ตัวแปร:** ŷ = ค่าทำนายสุดท้าย, ŷᵢ = ค่าจากโมเดล i, k = จำนวนโมเดล

---

## 5.3 Random Forest

**Random Forest = Bagging + Random Feature Selection**

**ความแตกต่างจาก Bagging:**
- สุ่มเลือก √n features (classification) หรือ n/3 features (regression)
- ลด correlation ระหว่างต้นไม้
- เพิ่ม diversity ให้กับ ensemble

---

## 5.3.2 Out-of-Bag (OOB) Error

**Bootstrap sampling ทำให้แต่ละต้นไม้ไม่เห็นข้อมูล ~37%**

<math xmlns="http://www.w3.org/1998/Math/MathML" display="block">
 <mrow>
 <mi>P</mi><mo>(</mo><mtext>not selected</mtext><mo>)</mo>
 <mo>=</mo>
 <msup>
 <mrow><mo>(</mo><mn>1</mn><mo>-</mo><mfrac><mn>1</mn><mi>n</mi></mfrac><mo>)</mo></mrow>
 <mi>n</mi>
 </msup>
 <mo>≈</mo>
 <mfrac><mn>1</mn><mi>e</mi></mfrac>
 <mo>≈</mo>
 <mn>0.368</mn>
 </mrow>
</math>

**ใช้ OOB samples ประเมินโมเดลได้โดยไม่ต้องแยก validation set**

---

## 5.4 ตัวอย่างโค้ด Bagging (1)

```python
class BaggingClassifier:
    def __init__(self, n_estimators=10, random_state=42):
        self.n_estimators = n_estimators
        self.estimators = []

def _bootstrap_sample(self, X, y, rng):
        n_samples = X.shape[0]
        indices = rng.choice(n_samples, size=n_samples,
                            replace=True)
        oob_indices = np.setdiff1d(np.arange(n_samples), indices)
        return X[indices], y[indices], oob_indices
```

---

## 5.4 ตัวอย่างโค้ด Bagging (2)

```python
def fit(self, X, y):
    for i in range(self.n_estimators):
        # Bootstrap sample
        X_sample, y_sample, oob_idx = self._bootstrap_sample(X, y)

# สร้างและฝึก base learner
        estimator = SimpleDecisionStump()
        estimator.fit(X_sample, y_sample)
        self.estimators.append(estimator)
```

---

## 5.4 ตัวอย่างโค้ด Random Forest

```python
class RandomForestClassifier:
    def fit(self, X, y):
        for i in range(self.n_estimators):
            # Bootstrap sample
            indices = rng.choice(n_samples, size=n_samples,
                                replace=True)
            # สุ่ม features
            feature_indices = rng.choice(n_features,
                                        size=max_feat,
                                        replace=False)
            # ฝึก Decision Stump
            estimator.fit(X_sample, y_sample, feature_indices)
```

---

## 5.4 ผลลัพธ์ Ensemble Methods

```
📌 Single Decision Stump
   Accuracy: 0.9250

📌 Bagging Classifier
   n_estimators=10: Accuracy=0.9500, OOB=0.9375
   n_estimators=50: Accuracy=0.9500, OOB=0.95

📌 Random Forest Classifier
   n_estimators=10: Accuracy=0.9500, OOB=0.9375
   n_estimators=50: Accuracy=0.9500, OOB=0.95

📊 Feature Importances:
   Feature 0: ██████████████████████████ (0.520)
   Feature 1: ████████████████████████ (0.480)
```

---

# 6. การเปรียบเทียบและการเลือกใช้งาน

---

## 6.1 ตารางเปรียบเทียบ (1)

| เกณฑ์ | Parametric | Non-Parametric |
|-------|------------|----------------|
| **จำนวนพารามิเตอร์** | คงที่ | เพิ่มตามข้อมูล |
| **สมมติฐาน** | มาก | น้อย |
| **ความเร็วฝึกสอน** | เร็ว | เร็ว (lazy) |
| **ความเร็วทำนาย** | เร็ว | ช้า |
| **หน่วยความจำ** | น้อย | มาก |

---

## 6.1 ตารางเปรียบเทียบ (2)

| เกณฑ์ | Decision Tree | Random Forest |
|-------|---------------|---------------|
| **จำนวนพารามิเตอร์** | ขึ้นกับความลึก | มาก |
| **Interpretability** | สูง | ต่ำ |
| **Overfitting** | สูง | ต่ำ |
| **ข้อมูลน้อย** | ไม่ดี | ไม่ดี |
| **ข้อมูลมาก** | ดี | ดีมาก |

---

## 6.2 แนวทางการเลือกโมเดล

```mermaid
%%{init: {'theme': 'base', 'themeVariables': { 'primaryColor': '#458588', 'primaryTextColor': '#ebdbb2', 'primaryBorderColor': '#83a598', 'lineColor': '#ebdbb2', 'secondaryColor': '#98971a', 'tertiaryColor': '#282828', 'background': '#282828'}}}%%
flowchart TB
 START["เริ่มต้น"]
 Q1{"ข้อมูลขนาดใหญ่?"}
 Q2{"ต้องการ Interpretability?"}
 Q3{"รู้รูปแบบข้อมูล?"}

A1["Random Forest"]
    A2["Decision Tree"]
    A3["Parametric Models"]
    A4["k-NN / Kernel"]

START --> Q1
    Q1 -->|Yes| A1
    Q1 -->|No| Q2
    Q2 -->|Yes| Q3
    Q2 -->|No| A4
    Q3 -->|Yes| A3
    Q3 -->|No| A2
```

---

## 6.3 กรณีศึกษา - Iris Dataset

```
📊 Dataset: Iris (150 samples, 4 features)

Model                     Accuracy     Type
--------------------------------------------
Logistic Regression       0.9733       Parametric
Naive Bayes               0.9533       Parametric
k-NN (k=3)                0.9600       Non-Param
k-NN (k=5)                0.9667       Non-Param
Decision Tree             0.9533       Tree
Random Forest             0.9600       Ensemble

🏆 Best: Logistic Regression (0.9733)
```

---

## 6.3 กรณีศึกษา - Wine Dataset

```
📊 Dataset: Wine (178 samples, 13 features)

Model                     Accuracy     Type
--------------------------------------------
Logistic Regression       0.9719       Parametric
Naive Bayes               0.9719       Parametric
k-NN (k=3)                0.9551       Non-Param
k-NN (k=5)                0.9607       Non-Param
Decision Tree             0.8876       Tree
Random Forest             0.9719       Ensemble

🏆 Best: Logistic Regression (0.9719)
```

---

## 6.3 ข้อสังเกตจากกรณีศึกษา

- Parametric models ทำงานได้ดีเมื่อสมมติฐานตรง
- k-NN ไวต่อ scaling และจำนวน features
- Ensemble methods มักให้ผลลัพธ์เสถียรกว่า
- **ไม่มีโมเดลใดดีที่สุดสำหรับทุกปัญหา**

---

# 7. สรุป

---

## 7.1 Parametric Models

**คุณลักษณะ:**
- มีจำนวนพารามิเตอร์คงที่
- ตั้งสมมติฐานเกี่ยวกับรูปแบบข้อมูลล่วงหน้า
- เหมาะกับข้อมูลขนาดเล็กถึงปานกลาง
- ฝึกสอนและทำนายได้เร็ว

**ตัวอย่าง:** Linear Regression, Logistic Regression, Naive Bayes

---

## 7.1 Non-Parametric Models

**คุณลักษณะ:**
- จำนวนพารามิเตอร์เพิ่มตามข้อมูล
- ไม่ตั้งสมมติฐานล่วงหน้า (distribution-free)
- เหมาะกับข้อมูลขนาดใหญ่และ pattern ซับซ้อน
- อาจช้าเมื่อข้อมูลมาก

**ตัวอย่าง:** k-NN, Kernel Regression, Decision Trees

---

## 7.1 Ensemble Methods

**คุณลักษณะ:**
- รวมโมเดลหลายตัวเพื่อผลลัพธ์ที่ดีกว่า
- Bagging ลด variance, Boosting ลด bias
- Random Forest เป็นที่นิยมเพราะทำงานได้ดี
- แลกมาด้วยความซับซ้อนและเวลาที่เพิ่มขึ้น

---

## 7.2 แนวทางปฏิบัติ

1. **เริ่มต้นด้วยโมเดลง่ายๆ** (Parametric) แล้วค่อยเพิ่มความซับซ้อน
2. **ทำความเข้าใจข้อมูล** ก่อนเลือกโมเดล
3. **ใช้ Cross-Validation** ในการเปรียบเทียบโมเดล
4. **พิจารณา Trade-offs** ระหว่างความแม่นยำ ความเร็ว และการตีความ
5. **Ensemble Methods** มักเป็นตัวเลือกที่ปลอดภัยสำหรับปัญหาทั่วไป

---

## 8. เอกสารอ้างอิง (1)

1. **Hastie, T., Tibshirani, R., & Friedman, J.** (2009). *The Elements of Statistical Learning*. Springer.
2. **Murphy, K. P.** (2012). *Machine Learning: A Probabilistic Perspective*. MIT Press.
3. **Breiman, L.** (2001). Random Forests. *Machine Learning*, 45(1), 5-32.
4. **Breiman, L.** (1996). Bagging Predictors. *Machine Learning*, 24(2), 123-140.
5. **Fix, E., & Hodges, J. L.** (1951). *Discriminatory Analysis*. USAF School of Aviation Medicine.

---

## 8. เอกสารอ้างอิง (2)

6. **Quinlan, J. R.** (1986). Induction of Decision Trees. *Machine Learning*, 1(1), 81-106.
7. **Nadaraya, E. A.** (1964). On Estimating Regression. *Theory of Probability*.
8. **Watson, G. S.** (1964). Smooth Regression Analysis. *Sankhyā*.
9. **Bishop, C. M.** (2006). *Pattern Recognition and Machine Learning*. Springer.
10. **James, G., et al.** (2013). *An Introduction to Statistical Learning*. Springer.

---

# คำถาม - ข้อสงสัย
<img src="/revealjs/pics/Designer.png" width="55%" />