Nền tảng Toán học cho Machine Learning

Machine Learning = Toán học + Data + Code

0.2 Ví dụ minh họa

Lộ trình học Toán cho ML:

1. Bước 1: Hiểu tại sao cần toán → ML = Tối ưu hóa toán học
2. Bước 2: Đại số tuyến tính → Vector, Ma trận, Eigenvalue
3. Bước 3: Giải tích → Đạo hàm, Gradient Descent
4. Bước 4: Thống kê → Mean, Variance, Correlation
5. Bước 5: Xác suất → Gaussian, Bayes
6. Bước 6: NumPy thực hành → Code hóa lý thuyết
7. Kết quả: Tự tin áp dụng ML → Hiểu sâu, debug tốt

1.1 Vector và Ma trận

Vector là mảng 1 chiều:

$\mathbf{x} = \begin{bmatrix} x_1 \\ x_2 \\ \vdots \\ x_n \end{bmatrix}$

Ma trận là mảng 2 chiều:

$\mathbf{A} = \begin{bmatrix} a_{11} & a_{12} & \cdots & a_{1n} \\ a_{21} & a_{22} & \cdots & a_{2n} \\ \vdots & \vdots & \ddots & \vdots \\ a_{m1} & a_{m2} & \cdots & a_{mn} \end{bmatrix}$

💡 Ví dụ thực tế:

1# Vector: 1 sample với 3 features
2student = [85, 90, 78]  # [Math, Physics, Chemistry]
3
4# Matrix: 4 students với 3 features
5class_scores = [
6    [85, 90, 78],  # Student 1
7    [92, 88, 95],  # Student 2
8    [78, 85, 82],  # Student 3
9    [88, 92, 90]   # Student 4
10]

1.2 Các phép toán cơ bản

1.3 Thực hành NumPy

Mô tả: Thực hành các phép toán vector và ma trận với NumPy để nắm vững concept.

1import numpy as np
2
3# Tạo vector
4x = np.array([1, 2, 3])
5print(f"Vector: {x}")
6print(f"Shape: {x.shape}")
7
8# Tạo ma trận
9A = np.array([[1, 2, 3],
10              [4, 5, 6]])
11print(f"Ma trận:\n{A}")
12print(f"Shape: {A.shape}")
13
14# Các phép toán
15B = np.array([[7, 8, 9],
16              [10, 11, 12]])
17
18# Cộng
19print(f"A + B:\n{A + B}")
20
21# Nhân scalar
22print(f"2 * A:\n{2 * A}")
23
24# Dot product
25a = np.array([1, 2, 3])
26b = np.array([4, 5, 6])
27print(f"a dot b: {np.dot(a, b)}")  # 1*4 + 2*5 + 3*6 = 32
28
29# Nhân ma trận
30C = np.array([[1, 2],
31              [3, 4],
32              [5, 6]])
33print(f"A @ C:\n{A @ C}")  # (2x3) @ (3x2) = (2x2)
34
35# Transpose
36print(f"A transpose:\n{A.T}")

Giải thích chi tiết:

1. np.array([1,2,3]): Tạo vector 1D (shape = (3,))
2. np.array([[...]]): Tạo ma trận 2D (shape = (rows, cols))
3. A + B: Element-wise addition - cộng từng phần tử tương ứng
4. 2 * A: Broadcasting - nhân mỗi phần tử với 2
5. np.dot(a, b): Tích vô hướng = $\sum a_i b_i$ = 1×4 + 2×5 + 3×6 = 32
6. A @ C: Nhân ma trận (operator @ = np.matmul())
   • Quy tắc: $(m \times n) \times (n \times p) = (m \times p)$
   • Số cột A (3) phải bằng số hàng C (3)
7. A.T: Transpose - đổi hàng thành cột

💡 Mẹo: Luôn kiểm tra shape trước khi nhân ma trận để tránh lỗi dimension mismatch!

1.4 Eigenvalue và Eigenvector

Định nghĩa:

Cho ma trận vuông $A$, nếu tồn tại vector $\mathbf{v} \neq 0$ và scalar $\lambda$ sao cho:

$A\mathbf{v} = \lambda\mathbf{v}$

Thì:

• $\lambda$ gọi là Eigenvalue (giá trị riêng)
• $\mathbf{v}$ gọi là Eigenvector (vector riêng)

Ý nghĩa:

• Eigenvector: Hướng không đổi khi nhân ma trận (chỉ bị co/giãn)
• Eigenvalue: Hệ số co/giãn theo hướng đó
• Ứng dụng: PCA (giảm chiều), Google PageRank, phân tích dao động

Tại sao quan trọng trong ML?

1.5 Thực hành Eigenvalue/Eigenvector

Mô tả: Tính eigenvalue và eigenvector của ma trận, verify kết quả bằng công thức $A\mathbf{v} = \lambda\mathbf{v}$.

1import numpy as np
2
3# Ma trận 2x2
4A = np.array([[4, 2],
5              [1, 3]])
6
7print("Ma trận A:")
8print(A)
9
10# Tính eigenvalues và eigenvectors
11eigenvalues, eigenvectors = np.linalg.eig(A)
12
13print(f"\nEigenvalues: {eigenvalues}")
14print(f"\nEigenvectors:\n{eigenvectors}")
15
16# Verify: A*v = lambda*v
17for i in range(len(eigenvalues)):
18    v = eigenvectors[:, i]
19    lambda_val = eigenvalues[i]
20    
21    Av = A @ v
22    lambda_v = lambda_val * v
23    
24    print(f"\nEigenvector {i+1}: {v}")
25    print(f"A @ v = {Av}")
26    print(f"λ × v = {lambda_v}")
27    print(f"Equal? {np.allclose(Av, lambda_v)}")

Giải thích chi tiết:

• np.linalg.eig(A): Tính eigenvalues và eigenvectors của ma trận vuông A

  • Return: (eigenvalues, eigenvectors) - tuple 2 phần tử
  • eigenvalues: array 1D chứa các eigenvalue
  • eigenvectors: ma trận 2D, mỗi cột là 1 eigenvector

• eigenvectors[:, i]: Lấy cột thứ i (eigenvector thứ i)

• Verify công thức $A\mathbf{v} = \lambda\mathbf{v}$:

  • Vế trái: A @ v - nhân ma trận với eigenvector
  • Vế phải: lambda_val * v - nhân eigenvalue với eigenvector
  • Nếu đúng: 2 vế bằng nhau (check bằng np.allclose())

Kết quả mong đợi:

• Ma trận 2×2 có 2 eigenvalues và 2 eigenvectors
• Công thức $A\mathbf{v} = \lambda\mathbf{v}$ được verify thành công
• Eigenvectors chỉ ra các hướng đặc trưng của ma trận A

1.6 Matrix Inverse và Determinant

Determinant (Định thức):

$\det(A) = |A|$

Ý nghĩa:

• Determinant = 0 → Ma trận singular (không khả nghịch)
• Determinant ≠ 0 → Ma trận invertible (khả nghịch)
• Determinant đo "thể tích" biến đổi khi nhân ma trận

Matrix Inverse (Ma trận nghịch đảo):

$A \times A^{-1} = A^{-1} \times A = I$

Ý nghĩa:

• $A^{-1}$ là ma trận "hoàn tác" phép biến đổi của A
• Chỉ tồn tại khi $\det(A) \neq 0$
• Ứng dụng: Giải hệ phương trình $A\mathbf{x} = \mathbf{b}$ → $\mathbf{x} = A^{-1}\mathbf{b}$

Mô tả: Tính determinant và inverse của ma trận, verify tính chất $A \times A^{-1} = I$.

1import numpy as np
2
3# Ma trận 3x3
4A = np.array([[1, 2, 3],
5              [0, 1, 4],
6              [5, 6, 0]])
7
8print("Ma trận A:")
9print(A)
10
11# Tính determinant
12det_A = np.linalg.det(A)
13print(f"\nDeterminant của A: {det_A:.2f}")
14
15# Kiểm tra khả nghịch
16if det_A != 0:
17    print("Ma trận khả nghịch (invertible)")
18    
19    # Tính inverse
20    A_inv = np.linalg.inv(A)
21    print(f"\nMa trận nghịch đảo A⁻¹:")
22    print(A_inv)
23    
24    # Verify: A @ A_inv = I (identity matrix)
25    I = A @ A_inv
26    print(f"\nA @ A⁻¹:")
27    print(I)
28    print(f"\nĐây có phải ma trận đơn vị? {np.allclose(I, np.eye(3))}")
29else:
30    print("Ma trận singular (không khả nghịch)")

Giải thích chi tiết:

• np.linalg.det(A): Tính định thức của ma trận A

  • Ma trận 2×2: $\det(A) = ad - bc$ với $A = \begin{bmatrix} a & b \\ c & d \end{bmatrix}$
  • Ma trận lớn hơn: dùng thuật toán LU decomposition

• np.linalg.inv(A): Tính ma trận nghịch đảo

  • Chỉ hoạt động khi det(A) ≠ 0
  • Nếu det(A) = 0: raise LinAlgError (singular matrix)

• Ma trận đơn vị $I$: đường chéo = 1, phần còn lại = 0

  • np.eye(n): tạo ma trận đơn vị kích thước n×n

• Verify tính chất $A \times A^{-1} = I$:

  • Nếu đúng: kết quả là ma trận đơn vị
  • Dùng np.allclose() để so sánh (tránh floating-point errors)

Kết quả mong đợi:

• Determinant khác 0 → ma trận khả nghịch
• $A \times A^{-1}$ cho ma trận đơn vị với 1 trên đường chéo, 0 ở ngoài

2.1 Các độ đo tập trung (Measures of Central Tendency)

2.2 Các độ đo phân tán (Measures of Dispersion)

Variance (Phương sai):

$\sigma^2 = \frac{1}{n}\sum_{i=1}^{n}(x_i - \bar{x})^2$

Ý nghĩa: Phương sai đo lường mức độ phân tán của dữ liệu quanh giá trị trung bình. Phương sai lớn = dữ liệu phân tán rộng, nhỏ = dữ liệu tập trung.

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

$\sigma = \sqrt{\sigma^2}$

Ý nghĩa: Độ lệch chuẩn là căn bậc 2 của phương sai, cùng đơn vị với dữ liệu gốc (dễ hiểu và diễn giải hơn). Ví dụ: Nếu data là chiều cao (cm), độ lệch chuẩn cũng là cm.

💡 Phân biệt:

• Phương sai: Đơn vị bình phương (ví dụ: cm²) - khó diễn giải
• Độ lệch chuẩn: Cùng đơn vị với data (ví dụ: cm) - dễ hiểu hơn

2.3 Ví dụ tính toán step-by-step

Dữ liệu: [2, 4, 4, 4, 5, 5, 7, 9]

Tính Mean (Trung bình): $\bar{x} = \frac{2+4+4+4+5+5+7+9}{8} = \frac{40}{8} = 5$

Tính Variance (Phương sai): $\sigma^2 = \frac{(2-5)^2 + (4-5)^2 + ... + (9-5)^2}{8} = \frac{9+1+1+1+0+0+4+16}{8} = 4$

Tính Standard Deviation (Độ lệch chuẩn): $\sigma = \sqrt{4} = 2$

Giải thích:

• Mean = 5: Giá trị trung bình của dataset
• Variance = 4: Dữ liệu phân tán với phương sai 4
• Std = 2: Trung bình các giá trị lệch khoảng 2 đơn vị so với mean

2.4 Thực hành với NumPy

Mô tả: Tính các chỉ số thống kê mô tả (descriptive statistics) cho dataset.

1import numpy as np
2
3data = np.array([2, 4, 4, 4, 5, 5, 7, 9])
4
5print(f"Mean: {np.mean(data)}")
6print(f"Median: {np.median(data)}")
7print(f"Variance: {np.var(data)}")
8print(f"Std: {np.std(data)}")
9print(f"Min: {np.min(data)}")
10print(f"Max: {np.max(data)}")
11print(f"Percentile 25: {np.percentile(data, 25)}")
12print(f"Percentile 75: {np.percentile(data, 75)}")

Giải thích:

• np.mean(): Trung bình cộng = $\frac{\sum x_i}{n}$ = 5.0
• np.median(): Giá trị giữa khi sắp xếp tăng dần (không bị outliers ảnh hưởng) = 4.5
• np.var(): Phương sai = mức độ phân tán data = 4.0
• np.std(): Độ lệch chuẩn = $\sqrt{variance}$ (cùng đơn vị với data) = 2.0
• np.percentile(data, 25): Quartile 1 (Q1) - 25% data nhỏ hơn giá trị này = 4.0
• np.percentile(data, 75): Quartile 3 (Q3) - 75% data nhỏ hơn giá trị này = 5.5

💡 Ứng dụng: Feature engineering, outlier detection, data normalization

3.1 Đạo hàm (Derivatives)

Định nghĩa:

Đạo hàm của hàm $f(x)$ tại điểm $x$ là:

$f'(x) = \lim_{h \to 0} \frac{f(x+h) - f(x)}{h}$

Ý nghĩa:

• Đạo hàm = tốc độ thay đổi của hàm số
• Ứng dụng ML: Tính gradient để tối ưu loss function

Các quy tắc đạo hàm cơ bản:

Chain Rule (Quy tắc chuỗi):

$\frac{d}{dx}[f(g(x))] = f'(g(x)) \cdot g'(x)$

Ứng dụng: Backpropagation trong Neural Networks

3.2 Gradient (Vector đạo hàm)

Định nghĩa:

Với hàm nhiều biến $f(x_1, x_2, ..., x_n)$, gradient là vector các đạo hàm riêng:

$\nabla f = \begin{bmatrix} \frac{\partial f}{\partial x_1} \\ \frac{\partial f}{\partial x_2} \\ \vdots \\ \frac{\partial f}{\partial x_n} \end{bmatrix}$

Ý nghĩa:

• Gradient chỉ hướng tăng nhanh nhất của hàm số
• Negative gradient chỉ hướng giảm nhanh nhất
• Ứng dụng: Gradient Descent tối ưu model

Ví dụ: Hàm $f(x, y) = x^2 + y^2$

$\nabla f = \begin{bmatrix} \frac{\partial f}{\partial x} \\ \frac{\partial f}{\partial y} \end{bmatrix} = \begin{bmatrix} 2x \\ 2y \end{bmatrix}$

Tại điểm $(1, 2)$: gradient = $\begin{bmatrix} 2 \\ 4 \end{bmatrix}$ → hàm tăng nhanh nhất theo hướng này.

3.3 Gradient Descent

Ý tưởng:

Tìm minimum của hàm $f(x)$ bằng cách di chuyển ngược hướng gradient:

$x_{new} = x_{old} - \alpha \nabla f(x_{old})$

Trong đó:

• $\alpha$: Learning rate (tốc độ học) - quyết định bước nhảy
• $\nabla f$: Gradient tại điểm hiện tại
• Lặp đến khi hội tụ (gradient ≈ 0)

Tại sao hiệu quả?

• Gradient chỉ hướng tăng nhanh nhất
• Di chuyển ngược gradient (negative) → đi về minimum

Ví dụ minh họa: Tìm minimum của $f(x) = x^2$

Bước 1: Tính đạo hàm: $f'(x) = 2x$

Bước 2: Update rule: $x_{new} = x_{old} - \alpha \cdot 2x_{old}$

Bước 3: Lặp:

• Start: $x = 10$, learning rate $\alpha = 0.1$
• Iteration 1: $x = 10 - 0.1 \times 20 = 8$
• Iteration 2: $x = 8 - 0.1 \times 16 = 6.4$
• Iteration 3: $x = 6.4 - 0.1 \times 12.8 = 5.12$
• ...
• Convergence: $x \to 0$ (minimum của $x^2$)

3.4 Thực hành Gradient Descent

Mô tả: Implement Gradient Descent từ scratch để tìm minimum của $f(x) = (x-3)^2$.

1import numpy as np
2import matplotlib.pyplot as plt
3
4# Hàm số: f(x) = (x-3)^2
5def f(x):
6    return (x - 3)**2
7
8# Đạo hàm: f'(x) = 2(x-3)
9def df(x):
10    return 2 * (x - 3)
11
12# Gradient Descent
13x = 10  # Điểm bắt đầu
14learning_rate = 0.1
15iterations = 20
16
17history = [x]  # Lưu lại quá trình
18
19for i in range(iterations):
20    gradient = df(x)
21    x = x - learning_rate * gradient
22    history.append(x)
23    print(f"Iteration {i+1}: x = {x:.4f}, f(x) = {f(x):.4f}, gradient = {gradient:.4f}")
24
25print(f"\nMinimum tìm được tại x = {x:.4f}")
26print(f"Giá trị minimum: f({x:.4f}) = {f(x):.4f}")
27
28# Visualize
29plt.figure(figsize=(12, 4))
30
31# Plot 1: Function curve
32plt.subplot(1, 2, 1)
33x_range = np.linspace(0, 10, 100)
34plt.plot(x_range, f(x_range), 'b-', label='f(x) = (x-3)²')
35plt.scatter(history, [f(h) for h in history], c='red', s=30, zorder=5)
36plt.plot(history, [f(h) for h in history], 'r--', alpha=0.5)
37plt.xlabel('x')
38plt.ylabel('f(x)')
39plt.title('Gradient Descent Path')
40plt.legend()
41plt.grid(True)
42
43# Plot 2: Convergence
44plt.subplot(1, 2, 2)
45plt.plot([f(h) for h in history], 'ro-')
46plt.xlabel('Iteration')
47plt.ylabel('f(x)')
48plt.title('Loss Convergence')
49plt.grid(True)
50
51plt.tight_layout()
52plt.show()

Giải thích chi tiết:

Thuật toán:

1. Khởi tạo: $x = 10$ (điểm bắt đầu tùy ý)
2. Tính gradient: $f'(x) = 2(x-3)$ tại điểm hiện tại
3. Update: $x_{new} = x - \alpha \cdot f'(x)$ với $\alpha = 0.1$
4. Lặp: Repeat cho đến khi hội tụ

Code breakdown:

• df(x): Đạo hàm của hàm số - chỉ hướng tăng
• x - learning_rate * gradient: Di chuyển ngược gradient để giảm
• learning_rate = 0.1: Bước nhảy mỗi iteration
  • Quá lớn: overshooting (vượt qua minimum)
  • Quá nhỏ: hội tụ chậm
• history: Lưu tất cả giá trị x qua các iterations để visualize

Visualization:

• Plot 1: Đường cong hàm số + path của Gradient Descent (điểm đỏ)
• Plot 2: Loss giảm dần theo iterations (convergence curve)

Kết quả mong đợi:

• Sau 20 iterations: $x \approx 3.0$ (minimum thực tế của $(x-3)^2$)
• Loss giảm từ $(10-3)^2 = 49$ về gần 0

💡 Tại sao quan trọng?

• Machine Learning: Tối ưu weights để minimize loss function
• Deep Learning: Backpropagation = Chain Rule + Gradient Descent
• Real-world: SGD, Adam, RMSprop đều dựa trên Gradient Descent

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

$Cov(X, Y) = \frac{1}{n}\sum_{i=1}^{n}(x_i - \bar{x})(y_i - \bar{y})$

Ý nghĩa: Covariance đo lường mối quan hệ tuyến tính giữa 2 biến số:

• $Cov > 0$: Tương quan thuận (X tăng → Y tăng)
• $Cov < 0$: Tương quan nghịch (X tăng → Y giảm)
• $Cov = 0$: Không tương quan tuyến tính

💡 Lưu ý: Covariance phụ thuộc vào scale của data (khó so sánh giữa các biến khác nhau).

3.2 Correlation (Hệ số tương quan Pearson)

$r = \frac{Cov(X, Y)}{\sigma_X \sigma_Y}$

Ý nghĩa: Correlation là chuẩn hóa Covariance về khoảng [-1, 1], không phụ thuộc scale.

💡 Phân biệt:

• Covariance: Đo hướng quan hệ (dương/âm), phụ thuộc scale
• Correlation: Chuẩn hóa về [-1, 1], dễ diễn giải và so sánh hơn

3.3 Thực hành

Mô tả: Đo lường mối quan hệ giữa 2 biến X và Y.

1import numpy as np
2
3X = np.array([1, 2, 3, 4, 5])
4Y = np.array([2, 4, 5, 4, 5])
5
6# Covariance
7cov_matrix = np.cov(X, Y)
8print(f"Covariance Matrix:\n{cov_matrix}")
9
10# Correlation
11corr_matrix = np.corrcoef(X, Y)
12print(f"Correlation Matrix:\n{corr_matrix}")
13print(f"Correlation coefficient: {corr_matrix[0, 1]:.4f}")

Giải thích:

• np.cov(X, Y): Trả về ma trận covariance 2x2: [[Var(X), Cov(X,Y)], [Cov(Y,X), Var(Y)]]
• cov_matrix[0, 1]: Covariance giữa X và Y (phần tử off-diagonal)
• np.corrcoef(X, Y): Correlation matrix (chuẩn hóa covariance về [-1, 1])
• corr_matrix[0, 1]: Pearson correlation coefficient

Kết quả mong đợi:

• Covariance > 0 vì X và Y có xu hướng tăng cùng nhau
• Correlation gần 1 cho thấy mối quan hệ thuận mạnh

4.1 Normal Distribution (Phân phối chuẩn / Gaussian)

$f(x) = \frac{1}{\sigma\sqrt{2\pi}} e^{-\frac{(x-\mu)^2}{2\sigma^2}}$

Trong đó:

• $\mu$: Mean (trung bình) - vị trí trung tâm
• $\sigma$: Standard deviation (độ lệch chuẩn) - độ rộng phân phối

Đặc điểm:

• Hình chuông (bell curve), đối xứng quanh $\mu$
• 68% data nằm trong $[\mu - \sigma, \mu + \sigma]$
• 95% data nằm trong $[\mu - 2\sigma, \mu + 2\sigma]$
• 99.7% data nằm trong $[\mu - 3\sigma, \mu + 3\sigma]$ (quy tắc 68-95-99.7)

Hình: Normal Distribution với các giá trị sigma khác nhau

💡 Ứng dụng trong ML:

• Gaussian Naive Bayes classifier
• Weight initialization trong Neural Networks
• Noise modeling (giả định nhiễu là Gaussian)

4.2 Bayes' Theorem (Định lý Bayes)

Công thức:

$P(A|B) = \frac{P(B|A) \cdot P(A)}{P(B)}$

Trong đó:

• $P(A|B)$: Posterior - xác suất A xảy ra khi biết B đã xảy ra
• $P(B|A)$: Likelihood - xác suất B xảy ra khi biết A đã xảy ra
• $P(A)$: Prior - xác suất ban đầu của A
• $P(B)$: Evidence - xác suất B xảy ra (normalization constant)

Ý nghĩa: Bayes' Theorem cho phép cập nhật xác suất khi có thông tin mới (từ Prior → Posterior).

Ví dụ thực tế: Medical Test

Bài toán:

• Bệnh X xuất hiện ở 1% dân số: $P(Disease) = 0.01$
• Test có độ chính xác 95%: $P(Positive | Disease) = 0.95$
• False positive rate 5%: $P(Positive | No Disease) = 0.05$

Câu hỏi: Nếu test dương tính, xác suất thực sự bị bệnh là bao nhiêu?

Giải:

$P(Disease | Positive) = \frac{P(Positive | Disease) \cdot P(Disease)}{P(Positive)}$

Tính $P(Positive)$ (Law of Total Probability):

$P(Positive) = P(Positive | Disease) \cdot P(Disease) + P(Positive | No Disease) \cdot P(No Disease)$

$P(Positive) = 0.95 \times 0.01 + 0.05 \times 0.99 = 0.0095 + 0.0495 = 0.059$

Thay vào Bayes:

$P(Disease | Positive) = \frac{0.95 \times 0.01}{0.059} = \frac{0.0095}{0.059} \approx 0.161 = 16.1\%$

Kết luận: Mặc dù test dương tính, xác suất thực sự bị bệnh chỉ 16.1% (không phải 95%!). Lý do: bệnh hiếm (prior thấp), nên false positives chiếm đa số.

💡 Bài học:

• Prior quan trọng - bệnh hiếm thì posterior cũng thấp dù test chính xác
• Đừng nhầm $P(A|B)$ với $P(B|A)$ (prosecutor's fallacy)

4.3 Thực hành Bayes' Theorem

Mô tả: Simulate medical test với 10,000 người để verify công thức Bayes.

1import numpy as np
2import matplotlib.pyplot as plt
3
4# Parameters
5n_people = 10000
6disease_rate = 0.01
7true_positive = 0.95  # P(Positive | Disease)
8false_positive = 0.05  # P(Positive | No Disease)
9
10# Simulate population
11has_disease = np.random.rand(n_people) < disease_rate
12
13# Test results
14test_result = np.zeros(n_people, dtype=bool)
15for i in range(n_people):
16    if has_disease[i]:
17        test_result[i] = np.random.rand() < true_positive
18    else:
19        test_result[i] = np.random.rand() < false_positive
20
21# Calculate P(Disease | Positive)
22positive_tests = test_result
23positive_and_diseased = positive_tests & has_disease
24
25p_disease_given_positive = positive_and_diseased.sum() / positive_tests.sum()
26
27print(f"Tổng số người: {n_people}")
28print(f"Số người bị bệnh: {has_disease.sum()} ({has_disease.mean()*100:.1f}%)")
29print(f"Số test dương tính: {positive_tests.sum()}")
30print(f"Số test dương tính VÀ bị bệnh: {positive_and_diseased.sum()}")
31print(f"\nP(Disease | Positive) = {p_disease_given_positive:.4f} ({p_disease_given_positive*100:.1f}%)")
32
33# Theoretical value
34p_positive = true_positive * disease_rate + false_positive * (1 - disease_rate)
35p_disease_given_positive_theory = (true_positive * disease_rate) / p_positive
36print(f"Theoretical P(Disease | Positive) = {p_disease_given_positive_theory:.4f} ({p_disease_given_positive_theory*100:.1f}%)")
37
38# Visualization
39fig, axes = plt.subplots(1, 2, figsize=(12, 4))
40
41# Plot 1: Confusion Matrix
42categories = ['True Negative', 'False Positive', 'False Negative', 'True Positive']
43counts = [
44    (~has_disease & ~test_result).sum(),
45    (~has_disease & test_result).sum(),
46    (has_disease & ~test_result).sum(),
47    (has_disease & test_result).sum()
48]
49colors = ['green', 'orange', 'red', 'blue']
50axes[0].bar(categories, counts, color=colors, alpha=0.7)
51axes[0].set_ylabel('Count')
52axes[0].set_title('Confusion Matrix')
53axes[0].tick_params(axis='x', rotation=45)
54
55# Plot 2: Conditional Probabilities
56probs = {
57    'Prior\nP(Disease)': disease_rate,
58    'Likelihood\nP(Pos|Disease)': true_positive,
59    'Posterior\nP(Disease|Pos)': p_disease_given_positive
60}
61axes[1].bar(probs.keys(), probs.values(), color=['blue', 'green', 'red'], alpha=0.7)
62axes[1].set_ylabel('Probability')
63axes[1].set_title("Bayes' Theorem: Prior → Posterior")
64axes[1].set_ylim(0, 1)
65
66plt.tight_layout()
67plt.show()

Giải thích chi tiết:

Simulation:

1. Generate population: 10,000 người, 1% bị bệnh (100 người)
2. Test sick people: 95% test dương tính (TP), 5% test âm tính (FN)
3. Test healthy people: 5% test dương tính (FP), 95% test âm tính (TN)
4. Calculate posterior: Trong tất cả test dương tính, bao nhiêu % thực sự bị bệnh?

Code breakdown:

• has_disease: Boolean array - True nếu bị bệnh
• test_result: Boolean array - True nếu test dương tính
• positive_and_diseased: Bitwise AND - True khi cả 2 điều kiện đúng
• positive_and_diseased.sum() / positive_tests.sum(): $P(Disease | Positive)$

Visualization:

• Plot 1: Confusion matrix - phân loại 4 trường hợp
  • TP (True Positive): Bệnh + Test dương tính ✅
  • TN (True Negative): Không bệnh + Test âm tính ✅
  • FP (False Positive): Không bệnh + Test dương tính ❌
  • FN (False Negative): Bệnh + Test âm tính ❌
• Plot 2: So sánh Prior (1%) → Posterior (16.1%)

Kết quả mong đợi:

• Simulated posterior ≈ 16.1% (khớp với theoretical value)
• Visualization cho thấy FP (false positive) nhiều hơn TP do bệnh hiếm

💡 Ứng dụng trong ML:

• Naive Bayes Classifier: Phân loại văn bản, spam detection
• Bayesian Optimization: Hyperparameter tuning
• A/B Testing: Cập nhật belief khi có data mới

4.4 Thực hành Normal Distribution

Mô tả: Sinh data từ phân phối Gaussian và visualize để hiểu đặc điểm.

1import numpy as np
2import matplotlib.pyplot as plt
3from scipy import stats
4
5# Tạo data từ normal distribution
6mu, sigma = 0, 1
7data = np.random.normal(mu, sigma, 1000)
8
9# Visualize
10plt.figure(figsize=(10, 4))
11plt.hist(data, bins=30, density=True, alpha=0.7)
12x = np.linspace(-4, 4, 100)
13plt.plot(x, stats.norm.pdf(x, mu, sigma), 'r-', lw=2)
14plt.title('Normal Distribution')
15plt.xlabel('Value')
16plt.ylabel('Density')
17plt.show()

Giải thích:

• np.random.normal(mu, sigma, 1000): Sinh 1000 samples từ $N(\mu, \sigma^2)$
• bins=30: Chia histogram thành 30 bins
• density=True: Normalize histogram thành density (tổng diện tích = 1)
• stats.norm.pdf(x, mu, sigma): Tính giá trị hàm mật độ (PDF) tại mỗi x
• Đường cong đỏ: Hàm mật độ lý thuyết của Normal Distribution

Kết quả mong đợi: Histogram khớp với đường cong lý thuyết (hình chuông)

5.1 Tại sao cần Scaling?

💡 Ví dụ: Nếu feature "tuổi" (20-60) và "lương" (5M-50M), lương sẽ chi phối model vì giá trị lớn hơn nhiều.

5.2 Các phương pháp Scaling

Standardization (Z-score Normalization):

$z = \frac{x - \mu}{\sigma}$

Ý nghĩa: Biến đổi data về phân phối chuẩn với mean = 0, std = 1. Giữ được hình dạng phân phối, không bị outliers ảnh hưởng nhiều.

Min-Max Normalization:

$x_{norm} = \frac{x - x_{min}}{x_{max} - x_{min}}$

Ý nghĩa: Co giãn data về khoảng [0, 1]. Giữ nguyên khoảng cách tương đối, nhưng rất nhạy với outliers.

💡 Khi nào dùng gì:

• StandardScaler: Neural Networks, Logistic Regression, SVM
• MinMaxScaler: Image data (0-255 → 0-1), KNN, algorithms nhạy với range
• RobustScaler: Data có nhiều outliers (dùng median và IQR)

5.3 Thực hành

Mô tả: So sánh StandardScaler và MinMaxScaler trên data có scale khác biệt lớn.

1from sklearn.preprocessing import StandardScaler, MinMaxScaler
2import numpy as np
3
4# Data: feature 1 (1-4), feature 2 (200-800)
5X = np.array([[1, 200],
6              [2, 400],
7              [3, 600],
8              [4, 800]])
9
10print("Original data:")
11print(X)
12
13# StandardScaler
14scaler_std = StandardScaler()
15X_std = scaler_std.fit_transform(X)
16print(f"\nStandardized (mean=0, std=1):")
17print(X_std)
18print(f"Mean: {X_std.mean(axis=0)}")
19print(f"Std: {X_std.std(axis=0)}")
20
21# MinMaxScaler
22scaler_mm = MinMaxScaler()
23X_mm = scaler_mm.fit_transform(X)
24print(f"\nMin-Max Normalized (range [0,1]):")
25print(X_mm)
26print(f"Min: {X_mm.min(axis=0)}")
27print(f"Max: {X_mm.max(axis=0)}")

Giải thích chi tiết:

StandardScaler:

• fit(): Tính mean $\mu$ và std $\sigma$ từ training data
• transform(): Áp dụng công thức $z = \frac{x - \mu}{\sigma}$ cho mỗi feature
• Kết quả: Mỗi feature có mean=0, std=1
• Ưu điểm: Giữ hình dạng phân phối, ít bị outliers ảnh hưởng

MinMaxScaler:

• fit(): Tìm $x_{min}$ và $x_{max}$ từ training data
• transform(): Áp dụng $x_{norm} = \frac{x - x_{min}}{x_{max} - x_{min}}$
• Kết quả: Mỗi feature trong khoảng [0, 1]
• Nhược điểm: Rất nhạy với outliers (outlier làm biến dạng toàn bộ data)

Kết quả mong đợi:

• StandardScaler: Mỗi cột có mean ≈ 0, std ≈ 1
• MinMaxScaler: Mỗi cột trong [0, 1], giá trị nhỏ nhất = 0, lớn nhất = 1

📝 Quiz: Kiểm tra kiến thức

Ưu và nhược điểm các phương pháp Scaling

📚 Tổng kết (Summary)

🏋️ Bài tập tự luyện

1import numpy as np
2data = np.array([10, 20, 30, 40, 50])
3print(f"Mean: {np.mean(data)}")
4print(f"Variance: {np.var(data)}")
5print(f"Std: {np.std(data)}")