# 📋 CHEAT SHEET - Công Thức Khai Phá Dữ Liệu

## 📊 PHẦN 1: TIỀN XỬ LÝ DỮ LIỆU

### 1.1 Thống Kê Mô Tả

#### **Mean (Trung bình)**
```
x̄ = Σxi / n
```
**Ví dụ:** [4, 5, 6] → x̄ = 15/3 = **5**

#### **Median (Trung vị)**
```
Sắp xếp → Lấy giá trị giữa (hoặc trung bình 2 giá trị giữa)
```
**Ví dụ:** [4, 5, 6] → Median = **5**  
**Ví dụ:** [4, 5, 6, 7] → Median = (5+6)/2 = **5.5**

#### **Mode (Yếu vị)**
```
Giá trị xuất hiện nhiều nhất
```
**Ví dụ:** [4, 5, 5, 6] → Mode = **5**

---

### 1.2 Boxplot

#### **Quartiles (Tứ phân vị)**
```
Q1 = Trung vị của nửa dưới
Q2 = Median
Q3 = Trung vị của nửa trên
IQR = Q3 - Q1
```

**Ví dụ:** [1, 2, 3, 4, 5, 6, 7, 8, 9]
- Q1 = Median([1,2,3,4]) = (2+3)/2 = **2.5**
- Q2 = **5**
- Q3 = Median([6,7,8,9]) = (7+8)/2 = **7.5**
- IQR = 7.5 - 2.5 = **5**

#### **Outliers (Giá trị ngoại lai)**
```
Lower fence = Q1 - 1.5 × IQR
Upper fence = Q3 + 1.5 × IQR
Outlier nếu: x < Lower fence hoặc x > Upper fence
```

---

### 1.3 Chuẩn Hóa (Normalization)

#### **Decimal Scaling**
```
x' = x / 10^j
(Chọn j sao cho Max(|x'|) < 1)
```
**Ví dụ:** [45, 67, 91] → j=2  
91 → 91/100 = **0.91**

---

#### **Min-Max Normalization**
```
x' = (x - min) / (max - min) × (new_max - new_min) + new_min
```

**Trường hợp đặc biệt [0, 1]:**
```
x' = (x - min) / (max - min)
```

**Ví dụ:** [4, 7, 10] về [0, 1]
- Min=4, Max=10, Range=6
- 7 → (7-4)/6 = **0.5**

**Ví dụ:** [4, 7, 10] về [-1, 1]
```
x' = (x - min) / (max - min) × 2 - 1
7 → (7-4)/6 × 2 - 1 = 0.5 × 2 - 1 = 0
```

---

#### **Z-Score Normalization**
```
x' = (x - μ) / σ
```

**Computational Formula cho σ:**
```
σ = √[Σxi²/n - x̄²]
```

**Ví dụ:** [4, 7, 10]
- x̄ = 21/3 = 7
- Σxi² = 16 + 49 + 100 = 165
- σ = √[165/3 - 7²] = √[55 - 49] = √6 = 2.45
- 7 → (7-7)/2.45 = **0**

---

#### **Modified Z-Score (Robust, dùng MAD thay vì σ)**

Phương pháp này **kháng nhiễu tốt hơn** khi có outliers.

```
x' = 0.6745 × (x - median) / MAD

Trong đó:
MAD = median(|xi - median|)
```

**Quy trình tính:**

**Bước 1:** Tính Median của dữ liệu
```
Sắp xếp → Lấy giá trị giữa
```

**Bước 2:** Tính độ lệch tuyệt đối
```
|xi - median| cho tất cả các điểm
```

**Bước 3:** Tính MAD
```
MAD = Median của các độ lệch tuyệt đối
```

**Bước 4:** Tính Modified Z-Score
```
x' = 0.6745 × (x - median) / MAD
```

**Ví dụ:** [1, 2, 3, 4, 100] (có outlier)

**Bước 1:** Median = 3

**Bước 2:** Độ lệch tuyệt đối
```
|1-3| = 2
|2-3| = 1
|3-3| = 0
|4-3| = 1
|100-3| = 97
→ [2, 1, 0, 1, 97]
```

**Bước 3:** MAD = Median([2, 1, 0, 1, 97])
```
Sắp xếp: [0, 1, 1, 2, 97]
MAD = 1
```

**Bước 4:** Tính Modified Z-Score
```
x=1:   0.6745 × (1-3)/1 = 0.6745 × (-2) = -1.349
x=2:   0.6745 × (2-3)/1 = 0.6745 × (-1) = -0.6745
x=3:   0.6745 × (3-3)/1 = 0
x=4:   0.6745 × (4-3)/1 = 0.6745 × 1 = 0.6745
x=100: 0.6745 × (100-3)/1 = 0.6745 × 97 = 65.43
```

**So sánh Z-Score thường:**
```
x̄ = (1+2+3+4+100)/5 = 22
σ = 43.36
x=100: (100-22)/43.36 = 1.8 ← Bị ảnh hưởng nặng bởi outlier!
```

**Ưu điểm Modified Z-Score:**
- ✅ Không bị ảnh hưởng bởi outliers
- ✅ Dùng Median thay vì Mean
- ✅ Dùng MAD thay vì σ
- ✅ Phát hiện outliers tốt hơn (thường dùng ngưỡng |z'| > 3.5)

---

### 1.4 Làm Trơn (Binning)

#### **Equal-Width Binning**
```
Bin width = (Max - Min) / số bins
```

**Interval Notation:**
```
Bin 1: [min, min+width)
Bin 2: [min+width, min+2×width)
...
Bin cuối: [..., max]
```

**Ví dụ:** [1,2,3,4,5,6,7,8,9] → 3 bins
- Width = (9-1)/3 = 2.67
- Bin 1: [1, 3.67) → 1,2,3
- Bin 2: [3.67, 6.33) → 4,5,6
- Bin 3: [6.33, 9] → 7,8,9

---

#### **Smoothing Methods**

**1. Bin Means**
```
Thay mỗi giá trị = Trung bình của bin
```
**Ví dụ:** Bin [1,2,3] → Mean = 2 → [2,2,2]

**2. Bin Medians**
```
Thay mỗi giá trị = Trung vị của bin
```
**Ví dụ:** Bin [1,2,3] → Median = 2 → [2,2,2]

**3. Bin Boundaries**
```
Thay mỗi giá trị = Min hoặc Max gần nhất
```
**Ví dụ:** Bin [1,2,3] → [1,1,3]

---

### 1.5 Correlation (Tương Quan)

#### **Phương pháp 1: Definitional**
```
r = Σ[(xi - x̄)(yi - ȳ)] / √[Σ(xi - x̄)² × Σ(yi - ȳ)²]
```

#### **Phương pháp 2: Computational (Khuyến nghị)**
```
Cov(X,Y) = Σ(xi·yi)/n - x̄·ȳ

σx = √[Σxi²/n - x̄²]

σy = √[Σyi²/n - ȳ²]

r = Cov(X,Y) / (σx × σy)
```

**Ví dụ:** X=[1,2,3], Y=[2,4,6]
```
Σxi = 6, Σyi = 12
Σxi² = 14, Σyi² = 56, Σ(xi·yi) = 28
x̄ = 2, ȳ = 4

Cov(X,Y) = 28/3 - 2×4 = 9.33 - 8 = 1.33
σx = √[14/3 - 4] = √[4.67 - 4] = 0.82
σy = √[56/3 - 16] = √[18.67 - 16] = 1.63
r = 1.33/(0.82 × 1.63) = 1.0
```

**Giải thích r:**
- r = 1: Tương quan dương hoàn hảo
- r = -1: Tương quan âm hoàn hảo
- r = 0: Không tương quan
- |r| > 0.7: Tương quan mạnh
- 0.3 < |r| < 0.7: Tương quan trung bình
- |r| < 0.3: Tương quan yếu

---

## 🔍 PHẦN 2: THUẬT TOÁN

### 2.1 Apriori Algorithm

#### **Support (Độ hỗ trợ)**
```
Support(X) = Số giao dịch chứa X / Tổng số giao dịch
```

**Ví dụ:**
- 10 giao dịch, {A,B} xuất hiện 3 lần
- Support({A,B}) = 3/10 = **30%**

---

#### **Confidence (Độ tin cậy)**
```
Confidence(X → Y) = Support(X ∪ Y) / Support(X)
```

**Ví dụ:**
- Support({A,B}) = 30%
- Support({A}) = 50%
- Confidence(A → B) = 30%/50% = **60%**

---

#### **Lift**
```
Lift(X → Y) = Confidence(X → Y) / Support(Y)
```

**Ví dụ:**
- Confidence(A → B) = 60%
- Support(B) = 40%
- Lift(A → B) = 60%/40% = **1.5**

**Giải thích Lift:**
- Lift > 1: X và Y có quan hệ dương
- Lift = 1: X và Y độc lập
- Lift < 1: X và Y có quan hệ âm

---

#### **Quy trình Apriori**

**Bước 1:** Tìm L₁ (1-itemsets thường xuyên)
```
Đếm từng item → Lọc theo min_support
```

**Bước 2:** Tìm L₂ (2-itemsets thường xuyên)
```
Kết hợp các items từ L₁ → Đếm → Lọc theo min_support
```

**Bước 3:** Lặp lại cho L₃, L₄, ... cho đến khi không còn itemsets nào

**Bước 4:** Sinh luật kết hợp từ frequent itemsets
```
Với mỗi itemset thường xuyên → Sinh tất cả các luật → Lọc theo min_confidence
```

---

### 2.2 ID3 Algorithm (Decision Tree)

#### **Entropy (Độ hỗn loạn)**
```
Entropy(S) = -Σ pi × log₂(pi)
```

**Ví dụ:** S có 9 Yes, 5 No (tổng 14)
```
p_yes = 9/14 = 0.643
p_no = 5/14 = 0.357

Entropy(S) = -(0.643 × log₂(0.643) + 0.357 × log₂(0.357))
           = -(0.643 × (-0.637) + 0.357 × (-1.485))
           = -(-0.410 - 0.530)
           = 0.940
```

---

#### **Information Gain (Lợi ích thông tin)**
```
Gain(S, A) = Entropy(S) - Σ (|Sv|/|S|) × Entropy(Sv)
```

**Ví dụ:** Attribute "Weather" có 3 giá trị (Sunny=5, Rain=4, Cloudy=5)
```
Entropy(S) = 0.940

Sunny: 2 Yes, 3 No → Entropy = 0.971
Rain: 4 Yes, 0 No → Entropy = 0
Cloudy: 3 Yes, 2 No → Entropy = 0.971

Gain = 0.940 - [(5/14)×0.971 + (4/14)×0 + (5/14)×0.971]
     = 0.940 - [0.347 + 0 + 0.347]
     = 0.940 - 0.694
     = 0.246
```

**Chọn attribute có Gain cao nhất làm root node**

---

#### **Quy trình ID3**

**Bước 1:** Tính Entropy(S) của tập dữ liệu
**Bước 2:** Tính Gain cho mỗi attribute
**Bước 3:** Chọn attribute có Gain cao nhất → Root node
**Bước 4:** Chia dữ liệu theo giá trị của attribute đã chọn
**Bước 5:** Lặp lại cho mỗi nhánh cho đến khi:
- Tất cả examples trong node có cùng class → Leaf node
- Không còn attribute nào → Leaf node (chọn class phổ biến nhất)
- Không còn example nào → Leaf node (chọn class phổ biến nhất từ parent)

---

### 2.3 K-means Clustering

#### **Euclidean Distance (Khoảng cách Euclid)**
```
d(p, q) = √[(x₁ - x₂)² + (y₁ - y₂)²]
```

**Ví dụ:** p(2,3), q(5,7)
```
d = √[(2-5)² + (3-7)²]
  = √[9 + 16]
  = √25
  = 5
```

**Cho n chiều:**
```
d(p, q) = √[Σ(pi - qi)²]
```

---

#### **SSE (Sum of Squared Errors)**
```
SSE = Σ distance²(điểm, tâm cluster)
```

**Ví dụ:** Cluster có tâm C(3,3), điểm A(2,3), B(4,5)
```
SSE = [(2-3)² + (3-3)²] + [(4-3)² + (5-3)²]
    = [1 + 0] + [1 + 4]
    = 1 + 5
    = 6
```

---

#### **Cập nhật Centroid**
```
Centroid mới = (Trung bình xi, Trung bình yi)
```

**Ví dụ:** Cluster có điểm (2,3), (4,5), (6,7)
```
Centroid = ((2+4+6)/3, (3+5+7)/3)
         = (4, 5)
```

---

#### **Quy trình K-means**

**Bước 1:** Chọn K centroids ban đầu

**Bước 2:** Gán mỗi điểm vào cluster gần nhất
```
Tính khoảng cách từ điểm đến tất cả centroids
→ Chọn centroid có khoảng cách nhỏ nhất
```

**Bước 3:** Cập nhật centroid mới
```
Tính trung bình tọa độ của tất cả điểm trong cluster
```

**Bước 4:** Lặp lại Bước 2-3 cho đến khi:
- Centroids không thay đổi, HOẶC
- Điểm không thay đổi cluster, HOẶC
- Đạt số vòng lặp tối đa

**Bước 5:** Tính SSE cuối cùng

---

## 📐 CÔNG THỨC BỔ SUNG

### Covariance (Hiệp phương sai)

#### **Definitional**
```
Cov(X,Y) = Σ(xi - x̄)(yi - ȳ) / n
```

#### **Computational (Khuyến nghị)**
```
Cov(X,Y) = Σ(xi·yi)/n - x̄·ȳ

Hoặc:
Cov(X,Y) = [Σ(xi·yi) - (Σxi)(Σyi)/n] / n
```

---

### Standard Deviation (Độ lệch chuẩn)

#### **Definitional**
```
σ = √[Σ(xi - x̄)² / n]
```

#### **Computational (Khuyến nghị)**
```
σ = √[Σxi²/n - x̄²]

Hoặc:
σ = √{[Σxi² - (Σxi)²/n] / n}
```

---

### Variance (Phương sai)

```
σ² = Σ(xi - x̄)² / n         (Definitional)
σ² = Σxi²/n - x̄²             (Computational)
```

---

## 🎯 BẢNG TÓM TẮT

### Các phương pháp chuẩn hóa

| Phương pháp | Công thức | Khi nào dùng |
|-------------|-----------|--------------|
| **Decimal Scaling** | x' = x/10^j | Nhanh, đơn giản |
| **Min-Max** | x' = (x-min)/(max-min)×(b-a)+a | Cần khoảng cụ thể [a,b] |
| **Z-Score** | x' = (x-μ)/σ | Dữ liệu phân phối chuẩn, ít outliers |
| **Modified Z-Score** | x' = 0.6745×(x-median)/MAD | **Có outliers**, cần robust |

**Lưu ý:**
- **Z-Score thường**: Nhạy cảm với outliers (dùng mean & σ)
- **Modified Z-Score**: Kháng nhiễu (dùng median & MAD)
- Phát hiện outliers: |Modified Z-Score| > 3.5

---

### Khi nào dùng Definitional vs Computational?

| Tình huống | Công thức | Lý do |
|-----------|-----------|-------|
| Có bảng chi tiết (xi - x̄) | Definitional | Đã tính sẵn |
| Chỉ có dữ liệu gốc | Computational | Nhanh hơn |
| Dùng máy tính/Excel | Computational | Ít sai số |
| Học lý thuyết | Definitional | Dễ hiểu |
| Thi trắc nghiệm | Computational | Tiết kiệm thời gian |

---

### Mức độ tương quan

| |r| | Mức độ |
|-----|--------|
| < 0.3 | Yếu |
| 0.3 - 0.7 | Trung bình |
| > 0.7 | Mạnh |

---

### Interval Notation

| Ký hiệu | Ý nghĩa | Ví dụ |
|---------|---------|-------|
| [a, b] | Bao gồm a VÀ b | [1, 5] → 1 ≤ x ≤ 5 |
| [a, b) | Bao gồm a, KHÔNG b | [1, 5) → 1 ≤ x < 5 |
| (a, b] | KHÔNG a, bao gồm b | (1, 5] → 1 < x ≤ 5 |

**Binning:**
- Equal-Width: [a, b) cho bins 1 đến n-1, [a, b] cho bin cuối
- Equal-Frequency: [a, b] cho tất cả bins

---

## 🔑 CÔNG THỨC QUAN TRỌNG NHẤT

### Top 12 công thức cần nhớ:

1. **Mean:** x̄ = Σxi / n
2. **Median:** Giá trị giữa sau khi sắp xếp
3. **Min-Max:** x' = (x - min)/(max - min)
4. **Z-Score:** x' = (x - μ)/σ
5. **Modified Z-Score:** x' = 0.6745×(x - median)/MAD
6. **σ (Computational):** √[Σxi²/n - x̄²]
7. **Cov (Computational):** Σ(xi·yi)/n - x̄·ȳ
8. **r (Correlation):** Cov(X,Y)/(σx × σy)
9. **Support:** Count(X)/Total
10. **Confidence:** Support(X∪Y)/Support(X)
11. **Entropy:** -Σ pi × log₂(pi)
12. **Euclidean Distance:** √[Σ(pi - qi)²]

---

## 💡 MẸO GHI NHỚ

**Computational vs Definitional:**
- **Definitional** = Dễ hiểu, nhiều bước
- **Computational** = Nhanh, ít sai số

**Normalization:**
- **Decimal Scaling** = Chia cho 10^j
- **Min-Max** = Đưa về khoảng [a, b]
- **Z-Score** = Chuẩn hóa theo phân phối (mean & σ)
- **Modified Z-Score** = Z-Score robust (median & MAD)

**Z-Score vs Modified Z-Score:**
- **Z-Score** = Dùng Mean & σ → Nhạy outliers
- **Modified Z-Score** = Dùng Median & MAD → Kháng outliers
- **MAD** = Median của |xi - median|
- **0.6745** = Hằng số để MAD tương đương σ khi phân phối chuẩn

**Binning:**
- **Equal-Width** = Chiều rộng đều → Bins có thể rỗng/đông
- **Equal-Frequency** = Số phần tử đều → Chiều rộng không đều

**Apriori:**
- **Support** = Tần suất xuất hiện
- **Confidence** = Khả năng Y xảy ra khi có X
- **Lift > 1** = X và Y liên quan

**ID3:**
- **Entropy cao** = Hỗn loạn (nhiều class khác nhau)
- **Gain cao** = Attribute tốt để phân chia
- Chọn **Gain cao nhất** làm root

**K-means:**
- Gán về **cluster gần nhất**
- Cập nhật centroid = **Trung bình điểm trong cluster**
- **SSE giảm** = Cluster tốt hơn

---

## ✅ CHECKLIST ÔN TẬP

### Trước khi thi, đảm bảo bạn biết:

**Tiền xử lý:**
- [ ] Tính Mean, Median, Mode
- [ ] Vẽ Boxplot, tìm outliers
- [ ] 4 phương pháp chuẩn hóa (Decimal, Min-Max, Z-Score, Modified Z-Score)
- [ ] Binning và smoothing
- [ ] Tính correlation (cả 2 cách: Definitional & Computational)

**Apriori:**
- [ ] Tính Support
- [ ] Tính Confidence
- [ ] Sinh luật kết hợp
- [ ] Biết khi nào dừng

**ID3:**
- [ ] Tính Entropy
- [ ] Tính Information Gain
- [ ] Chọn attribute tốt nhất
- [ ] Vẽ cây quyết định

**K-means:**
- [ ] Tính khoảng cách Euclid
- [ ] Gán điểm vào cluster
- [ ] Cập nhật centroid
- [ ] Tính SSE

---