Linear Regression – Từ Cơ Sở Lý Thuyết Đến Thực Hành Ứng Dụng

Nhóm: CONQ024
Học viên: Lê Hồ Anh Duy
Lớp: AI Việt Nam – AIO 2025
Ngày: 14/10/2025

1. Giới thiệu tổng quan

• Linear Regression là một trong những thuật toán nền tảng và lâu đời nhất trong Machine Learning. Thuật toán này được sử dụng để mô hình hóa mối quan hệ tuyến tính giữa một hoặc nhiều biến đầu vào (features) và một biến đầu ra liên tục (target).
• Mục tiêu của hồi quy tuyến tính là tìm ra đường thẳng “tốt nhất” thể hiện xu hướng dữ liệu, sao cho sai số giữa giá trị dự đoán và giá trị thực là nhỏ nhất.
• Dù đơn giản, nó là bước khởi đầu quan trọng giúp hiểu cách các mô hình phức tạp hơn hoạt động và đánh giá mức ảnh hưởng của từng yếu tố lên kết quả.

Ví dụ thực tế

• Giả sử ta có dữ liệu quảng cáo gồm 3 kênh: TV, Radio, Newspaper.

Sau khi huấn luyện mô hình, ta thu được phương trình:

$$\hat{Sales} = 0.045 \times TV + 0.187 \times Radio + 0.001 \times Newspaper + 2.5$$

• Mô hình hồi quy tuyến tính sẽ học cách xác định mức độ ảnh hưởng của từng kênh đến doanh số thông qua các hệ số (weights). Nếu hệ số của TV lớn hơn Radio và Newspaper, điều đó cho thấy chi tiêu cho TV có tác động mạnh hơn đến doanh số bán hàng.

2. Cơ sở lý thuyết chi tiết

2.1. Mô hình tổng quát

$$\hat{y} = w_1x_1 + w_2x_2 + \dots + w_d x_d + b$$

• $x_i$: đặc trưng (feature)
• $w_i$: trọng số
• $b$: hệ số chệch (bias)
• $\hat{y}$: giá trị dự đoán
• $y$: giá trị thực tế (ground truth, nhãn thật trong dữ liệu huấn luyện)

Ý tưởng: Hồi quy tuyến tính giả định rằng mối quan hệ giữa đầu vào và đầu ra là tuyến tính.

2.2. Hàm mất mát (Loss Function)

Để đo độ sai lệch giữa giá trị dự đoán và thực tế, ta có thể dùng Mean Squared Error (MSE):

$$L(w,b) = \frac{1}{n}\sum_{i=1}^n (\hat{y_i} - y_i)^2$$

• $n$: là số lượng mẫu (samples) trong tập dữ liệu huấn luyện.

  Mục tiêu của mô hình là tìm bộ tham số $(w, b)$ sao cho MSE nhỏ nhất.

2.3. Gradient

$$\frac{\partial L}{\partial w_j} = \frac{2}{n} \sum_{i=1}^{n} x_{ij}(\hat{y_i} - y_i)$$
$$\frac{\partial L}{\partial b} = \frac{2}{n} \sum_{i=1}^{n} (\hat{y_i} - y_i)$$

Khi gradient bằng 0, mô hình đạt trạng thái tối ưu – tức là đường hồi quy “khớp” tốt nhất với dữ liệu.

3. Gradient Descent và các biến thể

3.1. Nguyên lý

Để tối ưu hàm mất mát, ta dùng Gradient Descent (Thuật toán hạ dốc).
Từng bước, trọng số được cập nhật theo hướng ngược với gradient của hàm mất mát:
$$\partial w_j \leftarrow \partial w_j - \alpha \frac{\partial L}{\partial w_j} $$
$$\partial b \leftarrow \partial b - \alpha \frac{\partial L}{\partial b} $$
Hay
$$\theta \leftarrow \theta - \eta \nabla_\theta L$$
Trong đó:
- $\alpha$, $\eta$: tốc độ học (learning rate) – bước di chuyển mỗi lần cập nhật

• Nếu $\alpha$, $\eta$ quá lớn → dao động; nếu nhỏ → hội tụ chậm.

• $\frac{\partial L}{\partial w_j}$, $\frac{\partial L}{\partial b}$, $\nabla_\theta L$ là đạo hàm riêng thể hiện hướng tăng nhanh nhất của sai số

3.2. Trực quan

Hàm mất mát giống như “thung lũng” → gradient cho ta hướng dốc nhất, và ta “lăn quả bóng” xuống đáy – điểm tối ưu.

3.3. Ba biến thể Gradient Descent

4. Cài đặt Linear Regression bằng Python

4.1. Phiên bản cơ bản (vòng lặp từng mẫu)

• Đây là cách cài đặt Linear Regression từ đầu, không dùng thư viện.
• Mục tiêu: hiểu cách cập nhật tham số thủ công qua từng vòng lặp (epoch).

import numpy as np

def linear_regression_basic(X, y, lr=1e-4, epochs=1000):
    w, b = 0.0, 0.0
    N = len(X)
    for epoch in range(epochs):
        dw, db, loss = 0.0, 0.0, 0.0
        for i in range(N):
            y_hat = w * X[i] + b
            err = y_hat - y[i]
            dw += 2 * X[i] * err
            db += 2 * err
            loss += err**2
        w -= lr * (dw / N)
        b -= lr * (db / N)
        if epoch % 100 == 0:
            print(f"Epoch {epoch}: loss = {loss / N:.4f}")
    return w, b

• Ở đây ta đang làm Gradient Descent "thủ công" — từng bước mô phỏng đúng bản chất học của mô hình. Rất phù hợp để hiểu cơ chế tối ưu trước khi học đến vectorization hay sklearn.

4.2. Vectorization với NumPy

• Khi dữ liệu lớn, việc lặp từng mẫu là không hiệu quả.
• Vectorization giúp xử lý song song toàn bộ dữ liệu → nhanh hơn hàng chục lần.

def linear_regression_vectorized(X, y, lr=0.01, epochs=200):
    # X: ma trận (N, d), y: vector (N, 1)
    N, d = X.shape
    theta = np.zeros((d, 1))
    for epoch in range(epochs):
        y_hat = X @ theta
        grad = (2 / N) * X.T @ (y_hat - y)
        theta -= lr * grad
    return theta

4.3. So sánh hai cách cài đặt

4.4. Ví dụ minh họa kết quả chạy mô hình

import numpy as np

# Dữ liệu giả lập
X = np.array([[1.0], [2.0], [3.0], [4.0], [5.0]])
y = np.array([[2.2], [3.9], [6.1], [7.8], [10.2]])

# Thêm cột bias
X_b = np.hstack([np.ones((len(X), 1)), X])

# Huấn luyện bằng bản vectorized (hàm linear_regression_vectorized giả định đã định nghĩa)
theta = linear_regression_vectorized(X_b, y, lr=0.01, epochs=1000)

print("Trọng số học được:")
print("b (bias):", theta[0, 0])
print("w (hệ số):", theta[1, 0])

# Dự đoán
x_new = np.array([[1, 6]])  # [1 (bias), x=6]
y_pred = x_new @ theta
print("Dự đoán cho x=6:", y_pred)

Kết quả minh họa (ví dụ):

$$\hat{y} = 1.98x + 0.15$$

Giải thích:
Mô hình học được đường tuyến tính gần khớp với dữ liệu giả lập — điều này minh chứng Linear Regression hoạt động tốt khi mối quan hệ giữa biến độc lập và phụ thuộc là gần tuyến tính.

5. Các kỹ thuật đánh giá và tối ưu

5.1. Các chỉ số đánh giá

Để biết mô hình hồi quy hoạt động tốt hay không, ta sử dụng các thước đo sai số giữa giá trị dự đoán và giá trị thực tế.

Công thức MSE:

$$ \text{MSE} = \frac{1}{n}\sum_{i=1}^{n} (\hat{y}_i - y_i)^2 $$

Công thức R²:

$$ R^2 = 1 - \frac{\sum_{i=1}^{n} (\hat{y}_i - y_i)^2}{\sum_{i=1}^{n} (y_i - \bar{y})^2} $$

5.2. Regularization (chống quá khớp)

• Khi mô hình học "quá kỹ" dữ liệu huấn luyện, nó dễ bị overfit.
• Regularization giúp "ràng buộc" mô hình, tránh để các trọng số quá lớn.

Hàm mất mát tổng quát:
$$L_{total} = L_{loss} + \lambda *Penalty$$

• $L_{total}$: tổng hàm mất mát mà mô hình cần tối thiểu hóa (minimize).
• $L_{loss}$: phần sai số gốc giữa dự đoán và thực tế (ví dụ MSE, Cross-Entropy, v.v.).
• $\lambda$: hệ số điều chỉnh (regularization coefficient), xác định mức độ phạt —
  1. $\lambda$ lớn → phạt mạnh, mô hình đơn giản hơn (ít overfitting).
  2. $\lambda$ nhỏ → phạt nhẹ, mô hình linh hoạt hơn.
• $Penalty$: hàm phạt (regularization term), phụ thuộc vào loại kỹ thuật:
  1. Ridge (L2): $\sum_j w_j^2$
  2. Lasso (L1): $\sum_j |w_j|$
  3. ElasticNet: kết hợp cả hai.

Điều chỉnh $\lambda$ để cân bằng giữa bias và variance — giá trị $\lambda$ lớn hơn tăng phạt độ lớn hệ số, giúp giảm overfitting.

6. Kết luận và hướng phát triển

6.1. Kết luận

• Đã nắm vững cơ chế Linear Regression và Gradient Descent.
• Hiểu lợi ích của vectorization để tăng tốc tính toán.
• Nắm các metric đánh giá (MSE, RMSE, R²) và cách áp dụng.
• Biết hạn chế của mô hình tuyến tính với dữ liệu phi tuyến, biến động.

6.2. Hướng phát triển

1. Thử Ridge (L2) và Lasso (L1) để giảm overfitting.
2. Thử Polynomial Regression cho mối quan hệ phi tuyến.
3. Thêm lag features, rolling mean, time-based features cho chuỗi thời gian.
4. So sánh với Random Forest, XGBoost, LSTM cho dữ liệu phức tạp.

7.Nguồn tham khảo:

• AIO2025