Nền Tảng Toán Học Cho AI

Learning Objectives

• ✓Thao tác vector, ma trận và hiểu trị riêng, PCA, SVD
• ✓Hiểu đạo hàm, gradient và các biến thể gradient descent
• ✓Nắm xác suất, định lý Bayes và thống kê mô tả (hiệp phương sai, tương quan)
• ✓Hiểu entropy, lý thuyết thông tin và kiểm định giả thuyết
• ✓Nắm hàm chi phí, tối ưu lồi và chính quy hóa (regularization)

Đại Số Tuyến Tính: Vector & Ma Trận

Vector là mảng số một chiều biểu diễn một điểm dữ liệu; ma trận là mảng hai chiều dùng cho biến đổi và biểu diễn dữ liệu. Các phép toán cốt lõi: cộng vector/ma trận, nhân vô hướng, tích vô hướng (dot product). Trong AI, ma trận biểu diễn dữ liệu và trọng số của mạng nơ-ron — ví dụ mỗi ảnh MNIST 28×28 là một vector 784 chiều, và phép nhân W @ x chính là một lớp lan truyền xuôi (forward pass).

import numpy as np

# Ảnh xám 3x3 → ma trận
image = np.array([[255,   0, 128],
                  [ 64,  32, 200],
                  [ 10,  90, 170]])

# Mạng nơ-ron: trải ảnh thành vector, nhân với ma trận trọng số
W = np.random.randn(2, 9)   # 2 nơ-ron, 9 đầu vào
x = image.flatten()          # shape (9,)
output = W @ x               # nhân ma trận-vector → shape (2,)

Trị Riêng, PCA & SVD

Với ma trận A, trị riêng λ và vector riêng v thỏa Av = λv — vector riêng là các "hướng" mà dữ liệu trải rộng theo đó, trị riêng cho biết mức độ quan trọng (phương sai) của hướng đó. PCA (Phân tích thành phần chính) dùng chúng để giảm chiều dữ liệu, chỉ giữ lại các hướng quan trọng nhất. SVD phân rã ma trận A thành U, Σ, Vᵀ — dùng cho nén dữ liệu, phân tích ngữ nghĩa tiềm ẩn (LSA) trong NLP và hệ gợi ý (Netflix dùng SVD để dự đoán điểm đánh giá phim).

from sklearn.decomposition import PCA
import numpy as np

X = np.array([[2.5,2.4],[0.5,0.7],[2.2,2.9],[1.9,2.2],[3.1,3.0]])
pca = PCA(n_components=1)
X_reduced = pca.fit_transform(X)
print(pca.explained_variance_ratio_)
# Kết quả: [0.965] → giữ 96.5% phương sai chỉ với 1 thành phần

Giải Tích: Đạo Hàm & Gradient Descent

Đạo hàm đo mức độ thay đổi của hàm số khi đầu vào thay đổi; gradient mở rộng khái niệm này cho hàm nhiều biến. Đạo hàm riêng đo ảnh hưởng của từng đặc trưng lên đầu ra khi giữ các biến khác cố định. Gradient descent là thuật toán lặp cực tiểu hóa hàm chi phí bằng cách di chuyển ngược hướng gradient: w := w − lr·(dL/dw). Ba biến thể: Batch GD (dùng toàn bộ dữ liệu, ổn định nhưng chậm), Stochastic GD (dùng 1 mẫu, nhanh nhưng nhiễu) và Mini-batch GD (dùng 32–256 mẫu, cân bằng — mặc định trong thực tế).

# Hàm mất mát L(w) = (2w − 4)², cực tiểu tại w* = 2
# Đạo hàm: dL/dw = 4(2w − 4)

w = 0                          # trọng số ban đầu
lr = 0.1                       # learning rate
gradient = 4 * (2*w - 4)       # = -16 tại w=0
w_new = w - lr * gradient      # = 0 - 0.1*(-16) = 1.6
# → đã tiến về phía w* = 2

Xác Suất & Định Lý Bayes

Biến ngẫu nhiên là biến mà giá trị là kết quả của hiện tượng ngẫu nhiên; phân phối xác suất gán xác suất cho các kết quả (ví dụ phân phối Chuẩn/Gaussian, Nhị thức). Định lý Bayes P(A|B) = P(B|A)·P(A)/P(B) là nền tảng của bộ phân loại Naïve Bayes — ví dụ lọc thư rác: với P(Spam)=0.30, P("free"|Spam)=0.80, P("free")=0.40 thì P(Spam|"free") = 0.80·0.30/0.40 = 0.60, tức 60% khả năng là thư rác.

# Áp dụng Định lý Bayes
P_spam_given_free = (0.80 * 0.30) / 0.40   # = 0.60

# Cài đặt bằng scikit-learn
from sklearn.naive_bayes import MultinomialNB
model = MultinomialNB()
model.fit(X_train_counts, y_train)   # X = số lần xuất hiện từ
predictions = model.predict(X_test_counts)

Thống Kê: Mô Tả, Hiệp Phương Sai & Tương Quan

Thống kê mô tả tóm tắt dữ liệu số qua trung tâm (trung bình, trung vị, yếu vị), độ biến thiên (độ lệch chuẩn, phương sai) và hình dạng (độ lệch, độ nhọn). Hiệp phương sai (Covariance) đo xu hướng hai biến biến thiên cùng nhau: Cov>0 cùng chiều, Cov<0 ngược chiều. Hệ số tương quan Pearson (ρ) là hiệp phương sai chuẩn hóa, luôn trong [−1, +1] và không có đơn vị — r từ 0.9–1.0 là tương quan rất mạnh; p-value < 0.05 xác nhận tương quan là thật, không do ngẫu nhiên.

import numpy as np
import scipy.stats as stats

X = np.array([2, 4, 6, 8, 10])       # số giờ học
Y = np.array([50, 65, 75, 88, 95])   # điểm thi

cov = np.cov(X, Y)[0, 1]             # Cov(X,Y) > 0 → cùng chiều
r, p_value = stats.pearsonr(X, Y)
print(f'r = {r:.3f}')       # r = 0.993 → rất mạnh
print(f'p = {p_value:.4f}') # p = 0.0007 → có ý nghĩa thống kê

Entropy & Lý Thuyết Thông Tin

Entropy đo mức độ bất định / không thuần khiết (impurity) của dữ liệu: H = −Σ pᵢ·log₂(pᵢ). Entropy = 0 khi hoàn toàn chắc chắn (chỉ một khả năng); Entropy đạt max = log₂(n) khi mọi khả năng như nhau (ví dụ 4 lựa chọn → max = 2.0 bit). Trong cây quyết định, Độ lợi thông tin (Information Gain) = Entropy(cha) − Entropy(con có trọng số); cây chọn đặc trưng có Information Gain cao nhất tại mỗi nút.

import numpy as np

def entropy(probs):
    return -sum(p * np.log2(p) for p in probs if p > 0)

# Nút gốc: 10 Spam, 10 Not-Spam
H_root = entropy([0.5, 0.5])              # = 1.0 bit (bất định tối đa)

# Sau khi tách theo từ khóa 'discount':
# Trái (8 Spam, 2 Not) và Phải (2 Spam, 8 Not)
H_child = 0.5 * entropy([0.8, 0.2]) + 0.5 * entropy([0.2, 0.8])  # ≈ 0.722
info_gain = H_root - H_child              # = 0.278 bit → phép tách tốt!

Kiểm Định Giả Thuyết

Ta muốn chứng minh giả thuyết đối H₁ (ví dụ "Mô hình A khác Mô hình B") nhưng khó, nên tìm cách bác bỏ giả thuyết không H₀ ("A = B"). p-value là ngưỡng xác suất kiểm soát tỷ lệ dương tính giả; mức ý nghĩa α thường là 0.05. Nếu p-value < α → bác bỏ H₀, chấp nhận H₁. Các loại kiểm định phổ biến: kiểm định tương quan Pearson, kiểm định F (ANOVA) so sánh phương sai nhiều nhóm, và kiểm định T (một mẫu / hai mẫu) so sánh trung bình.

from scipy import stats

# Mô hình A: 850/1000 đúng (85.0%);  Mô hình B: 820/1000 (82.0%)
t_stat, p_value = stats.ttest_ind(results_A, results_B)
print(f'p-value = {p_value:.3f}')   # p = 0.031

# p = 0.031 < 0.05 → Bác bỏ H0: Mô hình A tốt hơn B có ý nghĩa
# F-Test (nhiều nhóm): stats.f_oneway(x, y, z)
# T-Test một mẫu:      stats.ttest_1samp(X, given_mean)

Tối Ưu Hóa: Hàm Chi Phí, Tối Ưu Lồi & Regularization

Hàm chi phí đánh giá mô hình hoạt động tốt đến đâu — MSE cho hồi quy, Cross-Entropy cho phân loại; mục tiêu là cực tiểu hóa nó. Hàm lồi (convex) đảm bảo cực tiểu cục bộ chính là cực tiểu toàn cục, giúp tối ưu đơn giản (SVM dựa vào tính chất này). Chính quy hóa (Regularization) chống quá khớp bằng cách thêm phạt vào hàm chi phí: L1 (Lasso) cộng giá trị tuyệt đối của trọng số, L2 (Ridge) cộng bình phương trọng số — khuyến khích mô hình đơn giản, tổng quát hóa tốt hơn.

import numpy as np

# MSE (Hồi quy)
y_true = np.array([3.0, 5.0, 7.0])
y_pred = np.array([2.8, 5.2, 6.5])
mse = np.mean((y_true - y_pred) ** 2)   # = 0.11 (nhỏ = tốt)

# Binary Cross-Entropy (Phân loại)
# y=1, pred=0.9 (tự tin, đúng) → L = -log(0.9) = 0.105  (nhỏ)
# y=1, pred=0.1 (tự tin, sai)  → L = -log(0.1) = 2.303  (lớn!)
# CE phạt rất nặng dự đoán sai mà lại tự tin