1. Linear Regression

1.1 Motivation — Vì sao chúng ta cần Linear Regression?

Câu chuyện bắt đầu

Giả sử bạn là một nhà phân tích dữ liệu trong một công ty bất động sản.
Trước mặt bạn là một bảng dữ liệu gồm diện tích nhà (m²) và giá bán (triệu đồng) của hàng trăm căn hộ ở TP.HCM.
Bạn nhận thấy rằng:

Càng lớn, giá càng cao — nhưng không theo một tỉ lệ hoàn toàn cố định.

Một câu hỏi tự nhiên xuất hiện:

“Liệu có tồn tại một mối quan hệ tuyến tính gần đúng giữa diện tích và giá nhà không?”
“Nếu có, ta có thể viết một phương trình nào đó để dự đoán giá cho căn hộ mới chỉ từ diện tích của nó?”

Đó chính là nơi Linear Regression (hồi quy tuyến tính) xuất hiện.

Ý tưởng cốt lõi

Linear Regression là một trong những mô hình cơ bản nhất của machine learning,
nằm trong nhóm supervised learning (học có giám sát).
Điều này có nghĩa là mô hình học từ các cặp dữ liệu có nhãn:
đầu vào $x$ (feature) và đầu ra $y$ (target).

Cụ thể, nếu ta có tập dữ liệu gồm các cặp:

$$ (x_i, y_i), \quad i = 1, 2, ..., n $$

với $x_i$ là diện tích và $y_i$ là giá nhà,
Linear Regression tìm các hệ số $w_0, w_1$ sao cho:

$$ \hat{y}_i = w_0 + w_1 x_i $$

gần nhất với $y_i$ thật sự trong dữ liệu.
Nói cách khác, ta đang vẽ một đường thẳng đi qua đám mây điểm sao cho tổng sai số nhỏ nhất.

Liên hệ thực tế & Dataset phổ biến

Linear Regression được ứng dụng rộng rãi trong rất nhiều lĩnh vực khác nhau,
từ kinh tế, năng lượng, y tế cho đến khí hậu.
Một vài ví dụ tiêu biểu:

Dù ngày nay ta có vô số mô hình phức tạp hơn như XGBoost, Random Forest, hay Neural Networks,
Linear Regression vẫn được xem là “Hello World” của Machine Learning —
nơi mọi người bắt đầu học cách máy tính mô hình hóa mối quan hệ giữa các biến.

1.2 Xây dựng mô hình

Mô hình tổng quát

Linear Regression giả định rằng biến đầu ra $y \in \mathbb{R}$ có thể được biểu diễn như một tổ hợp tuyến tính của các biến đầu vào:

$$ \hat{y} = \theta_0 + \theta_1 x_{1} + \theta_2 x_{2} + \dots + \theta_m x_{m} $$

Hàm mất mát bình phương trung bình cho N phần tử(sample) :

$$ \mathcal{L}(\beta) = \frac{1}{2N} \sum_{i=1}^N (y_i - \hat{y}_i)^2 $$

Vectorization

Thay vì xử lý từng mẫu riêng lẻ, ta biểu diễn toàn bộ dữ liệu theo dạng ma trận-vector:

Với một điểm dữ liệu:

$$ \mathbf{x} = \begin{bmatrix} 1 \\ x_1 \\ x_2 \\ \vdots \\ x_m \end{bmatrix} \in \mathbb{R}^{(m+1) \times 1}, \quad y \in \mathbb{R} $$

và tham số mô hình:

$$ \boldsymbol{\theta} = \begin{bmatrix} \theta_0 \\ \theta_1 \\ \vdots \\ \theta_m \end{bmatrix} \in \mathbb{R}^{(m+1) \times 1} $$

Hàm dự đoán (predictive function):

$$ \hat{y} = f_{\boldsymbol{\theta}}(\mathbf{x}) = \boldsymbol{\theta}^\top \mathbf{x} $$

Hàm mất mát (loss function) cho một mẫu:

$$ \mathcal{L}(\boldsymbol{\theta}; \mathbf{x}, y) = \frac{1}{2} \left( f_{\boldsymbol{\theta}}(\mathbf{x}) - y \right)^2 $$

Toàn bộ dữ liệu gồm $n$ mẫu

Gộp toàn bộ dữ liệu vào dạng ma trận:

$$ X = \begin{bmatrix} \mathbf{x}^{(1)} & \mathbf{x}^{(2)} & \dots & \mathbf{x}^{(n)} \end{bmatrix} \in \mathbb{R}^{(m+1) \times n}, \quad Y = \begin{bmatrix} y^{(1)} & y^{(2)} & \dots & y^{(n)} \end{bmatrix} \in \mathbb{R}^{1 \times n} $$

Vector hóa phép dự đoán và mất mát

Hàm dự đoán cho toàn bộ dữ liệu:

$$ f_{\theta}(X) = \begin{bmatrix} {\theta}^\top \mathbf{x}^{(1)} & {\theta}^\top \mathbf{x}^{(2)} & \dots & {\theta}^\top \mathbf{x}^{(n)} \end{bmatrix} = {\theta}^\top X $$
Ta có :
$$ \left( {\theta}^\top X - Y \right) = \begin{bmatrix} {\theta}^\top \mathbf{x}^{(1)} - y^{(1)}& {\theta}^\top \mathbf{x}^{(2)} - y^{(2)}& \dots & {\theta}^\top \mathbf{x}^{(n)} - y^{(n)} \end{bmatrix} $$
Từ đó ,hàm mất mát toàn phần (Mean Squared Error):

$$ \mathcal{L}({\theta}; X, Y) =\frac{1}{2n} \sum_{i=1}^n ({\theta}^\top \mathbf{x}^{(i)} - y^{(i)})^2 =\frac{1}{2n} \left( {\theta}^\top X - Y \right) \left( {\theta}^\top X - Y \right)^\top $$

Điều này không chỉ giúp đơn giản hóa lý thuyết, mà còn tăng tốc tính toán đáng kể trong thực nghiệm (NumPy, PyTorch, TensorFlow).

1.3 Maximum Likelihood Estimation (MLE)

🔹 1. Bối cảnh tổng quát

Giả sử ta có một mô hình xác suất $p(y \mid x, \theta)$ mô tả cách dữ liệu được sinh ra,
trong đó:
- $x$: biến đầu vào (features)
- $y$: biến đầu ra (label)
- $\theta$: tập tham số cần ước lượng

Tập dữ liệu huấn luyện gồm $n$ mẫu độc lập và phân phối giống nhau (i.i.d.):

$$ \mathcal{D} = \{(x_1, y_1), (x_2, y_2), \dots, (x_n, y_n)\} $$

🔹 2. Likelihood function

Xác suất sinh ra toàn bộ dữ liệu (với giả định độc lập) là tích các xác suất riêng lẻ:
$$ p(y_1, \dots, y_n \mid x_1, \dots, x_n, \theta) = \prod_{i=1}^n p(y_i \mid x_i, \theta) $$

Gọi đây là hàm khả năng (likelihood function):

$$ \mathcal{L}(\theta) = p(\mathcal{D} \mid \theta) = \prod_{i=1}^n p(y_i \mid x_i, \theta) $$

🔹 3. Log-likelihood

Để đơn giản hóa tích thành tổng, ta lấy log:

$$ \ell(\theta) = \log \mathcal{L}(\theta) = \sum_{i=1}^n \log p(y_i \mid x_i, \theta) $$

🔹 4. Nguyên tắc MLE

Ước lượng cực đại hợp lý (Maximum Likelihood Estimation) chọn $\theta$
sao cho xác suất sinh ra dữ liệu quan sát là lớn nhất:

$$ \boxed{ \hat{\theta}_{\text{MLE}} = \arg\max_{\theta} \ell(\theta) = \arg\max_{\theta} \sum_{i=1}^n \log p(y_i \mid x_i, \theta) } $$

1.4 Dưới góc nhìn xác suất

Linear Regression giả định rằng biến đầu ra $y \in \mathbb{R}^n$
có thể được biểu diễn như một tổ hợp tuyến tính của các biến đầu vào $X \in \mathbb{R}^{n \times (m+1)}$:

$$ y = X\theta + \epsilon, \quad \epsilon \sim \mathcal{N}(0, \sigma^2 I) $$

Mỗi điểm dữ liệu $y^{(i)}$ được giả định sinh ra từ phân phối Gaussian:

$$ y^{(i)} \sim \mathcal{N}( (x^{(i)})^\top \theta, \sigma^2) $$
Hàm mật độ xác suất:
$$ p(y^{(i)} \mid x^{(i)}, \theta, \sigma^2) = \frac{1}{\sqrt{2\pi\sigma^2}} \exp\!\left(-\frac{(y^{(i)} - (x^{(i)})^\top \theta)^2}{2\sigma^2}\right) $$

Vì các quan sát độc lập (i.i.d.),
xác suất sinh ra toàn bộ tập dữ liệu là tích các xác suất riêng lẻ:

$$ p(y_1, \dots, y_n \mid x_1, \dots, x_n, \theta, \sigma^2) = \prod_{i=1}^n p(y^{(i)} \mid x^{(i)}, \theta, \sigma^2) $$

Khi đó, hàm khả năng (likelihood) là:

$$ \mathcal{L}(\theta, \sigma^2) = p(\mathcal{D} \mid \theta, \sigma^2) = \prod_{i=1}^n \frac{1}{\sqrt{2\pi\sigma^2}} \exp\!\left(-\frac{(y^{(i)} - (x^{(i)})^\top \theta)^2}{2\sigma^2}\right) $$

Lấy log để đơn giản hóa:

$$ \log p(y \mid X, \theta, \sigma^2) = -\frac{n}{2}\log(2\pi\sigma^2) - \frac{1}{2\sigma^2}(y - X\theta)^\top (y - X\theta) $$

Vì hạng đầu không phụ thuộc vào $\theta$, nên ta có thể tối thiểu hóa bình phương sai số thay thế cho việc cực đại log-likelihood:

$$ \min_\theta (y - X\theta)^\top (y - X\theta) $$

Ta muốn tìm $\theta^*$ sao cho $L(\theta)$ đạt giá trị nhỏ nhất.

1.5 Tìm nghiệm tối ưu (Điều kiện cực trị theo Fermat)

Hàm mất mát (Loss function) trong Linear Regression viết là:

$$ L(\theta) = (y - X\theta)^\top (y - X\theta) $$

Ta cần tìm $\theta^*$ sao cho $L(\theta)$ đạt giá trị nhỏ nhất.

Đạo hàm theo vector (gradient)

Khai triển:

$$ L(\theta) = y^\top y - 2y^\top X\theta + \theta^\top X^\top X\theta $$

Lấy đạo hàm theo $\theta$:

$$ \nabla_\theta L(\theta) = -2X^\top y + 2X^\top X\theta $$

Áp dụng định lý Fermat (First-order optimality condition)

Theo định lý Fermat,
một điểm cực trị (cực tiểu hoặc cực đại) xảy ra khi đạo hàm bằng 0:

$$ \nabla_\theta L(\theta) = 0 $$

Thay vào:

$$ -2X^\top y + 2X^\top X\theta = 0 $$

Rút gọn:

$$ \boxed{X^\top X\theta = X^\top y} $$

Giải nghiệm đóng (Closed-form solution)

Giả sử ma trận $X^\top X$ khả nghịch (invertible):

$$ \boxed{ \hat{\theta} = (X^\top X)^{-1}X^\top y } $$

Đây chính là nghiệm tối ưu duy nhất (do $L(\theta)$ là hàm bậc hai lồi).
Nó được gọi là Normal Equation trong Linear Regression.

1.6 Gradient Descent and Convex Optimization View

Hàm mất mát $L(\theta) = (y - X\theta)^\top (y - X\theta)$ là 1 hàm lồi theo $\theta$ vì:

$$ \nabla^2_\theta L(\theta) = \frac{1}{n} X^T X \succeq 0 $$

• Nếu $X^T X$ dương xác định (positive definite) → $L$ lồi nghiêm ngặt (strictly convex) → nghiệm tối ưu duy nhất.
• Nếu $X^T X$ chỉ dương bán xác định (positive semidefinite) → có thể tồn tại vô số nghiệm (các feature phụ thuộc tuyến tính).

✅ Tính lồi đảm bảo rằng khi ta tìm đạo hàm bằng 0,
nghiệm nhận được chính là điểm cực tiểu toàn cục,
không bị “mắc kẹt” ở cực tiểu cục bộ như trong mạng nơ-ron sâu.

Khi dữ liệu lớn (ví dụ hàng triệu dòng), việc tính $(X^TX)^{-1}$ trở nên tốn kém.
Lúc này, ta dùng Gradient Descent (GD) để tối ưu dần giá trị hàm mất mát:

$$ \theta^{(t+1)} = \theta^{(t)} - \eta \, \nabla_\theta L(\theta^{(t)}) = \theta^{(t)} - \frac{\eta}{n} X^\top(X\theta^{(t)} - y) $$

• $\eta$: learning rate, điều chỉnh độ lớn mỗi bước di chuyển.
• Cập nhật lặp cho đến khi hội tụ (khi gradient gần 0).
• Có thể mở rộng thành Stochastic / Mini-batch Gradient Descent để xử lý dữ liệu lớn hơn, hoặc chạy song song trên GPU.

💡 Trong không gian tham số, Gradient Descent "trượt" dần theo hướng ngược lại với gradient —
đi từ vị trí hiện tại $\theta^{(t)}$ đến vùng thấp nhất của bề mặt mất mát $L(\theta)$.

1.7 Mở rộng từ Linear Regression

💡 Cùng framework MLE nhưng thay đổi giả định phân phối hoặc hàm regularization,
ta có thể sinh ra cả họ mô hình Regression quen thuộc trong ML hiện đại.

1.8 Nói thêm về vector hoá: Tại sao nó lại hiệu quả?

Vector hóa không phải là một thuật toán, mà là một kỹ thuật cho phép thực hiện các phép toán trên toàn bộ mảng dữ liệu (vector hoặc ma trận) cùng một lúc.

Vectorization không phải là một thuật toán mới, mà là một kỹ thuật triển khai giúp tối ưu tốc độ và tài nguyên. Dưới đây là các yếu tố chính:

1. Loại bỏ "Gánh Nặng" của Python: Vòng lặp vs. Mã lệnh cấp thấp

Vòng lặp for trong Python:
- Là ngôn ngữ thông dịch → xử lý từng phần tử, có nhiều chi phí ẩn.
- Với mỗi phần tử:
- Lấy giá trị a[i], kiểm tra kiểu.
- Lấy b[i], kiểm tra kiểu.
- Thực hiện phép cộng và lưu c[i].

➡️ Chi phí lặp lại hàng triệu lần → rất chậm.

Vectorization (NumPy):
- Khi viết C = A + B, NumPy gọi mã C/Fortran cấp thấp đã biên dịch.
- Tất cả phép tính diễn ra ngoài Python, loại bỏ chi phí của vòng lặp.

2. Xử lý song song ở cấp độ phần cứng: SIMD 🚀

SIMD (Single Instruction, Multiple Data) cho phép CPU thực hiện một lệnh trên nhiều dữ liệu cùng lúc.

• Không có SIMD (vòng lặp for): CPU xử lý từng phần tử → chậm.
• Có SIMD (vectorization): CPU cộng 4–8 phần tử cùng lúc → nhanh gấp nhiều lần.

NumPy tận dụng SIMD nên tốc độ vượt trội trên dữ liệu lớn.

3. Tối ưu hóa luồng dữ liệu: Bộ nhớ đệm (CPU Cache)

• Mảng NumPy: dữ liệu lưu liền kề trong bộ nhớ → dễ "cache hit".
• Danh sách Python: dữ liệu rải rác → nhiều "cache miss".

➡️ Khi dữ liệu nằm sẵn trong cache, CPU không cần chờ RAM → tăng tốc độ đáng kể.

Bảng tóm tắt so sánh

1.9 Các Hàm Mất mát (Loss Functions)

Một hàm mất mát tốt cần đảm bảo:
- Liên tục (continuous)
- Khả vi (differentiable)
để có thể tối ưu hiệu quả.

1️⃣ Mean Squared Error (MSE — Sai số Bình phương Trung bình)

$$ L(\hat{y}, y) = \frac{1}{N} \sum_{i=1}^{N} (\hat{y}_i - y_i)^2 $$
Ưu điểm:
- Hàm lồi, khả vi tại mọi điểm → dễ tối ưu.
- Gradient giảm dần gần điểm tối ưu → hội tụ ổn định.

Nhược điểm:
- Rất nhạy cảm với outliers do sai số được bình phương.

2️⃣ Mean Absolute Error (MAE — Sai số Tuyệt đối Trung bình)

$$ L(\hat{y}, y) = \frac{1}{N} \sum_{i=1}^{N} |\hat{y}_i - y_i| $$

Ưu điểm:
- Ít bị ảnh hưởng bởi outliers.

Nhược điểm:
- Gradient có độ lớn không đổi, gây khó khăn khi hội tụ chính xác.
- Không khả vi tại điểm sai số bằng 0.

3️⃣ Huber Loss — Kết hợp MSE & MAE

Huber Loss hoạt động giống MSE khi sai số nhỏ, và giống MAE khi sai số lớn.

$$ L(\hat{y}, y) = \begin{cases} \frac{1}{2}(\hat{y} - y)^2, & \text{khi } |\hat{y} - y| \le \delta \\ \delta |\hat{y} - y| - \frac{1}{2}\delta^2, & \text{khi } |\hat{y} - y| > \delta \end{cases} $$

Ưu điểm:
- Ổn định với outliers, hội tụ mượt mà.

Nhược điểm:
- Cần tinh chỉnh siêu tham số (\delta).
- Giá trị $delta$ quyết định điểm chuyển giữa hai chế độ:
- $|\hat{y} - y| < \delta$: giống MSE.
- $|\hat{y} - y| > \delta$: giống MAE.

Trong ví dụ minh họa, $\delta = 2$.

1.10 Kỹ thuật Cải thiện Huấn luyện

1️⃣ Chuẩn hóa Dữ liệu (Data Normalization)

Vấn đề:
Các feature có thang đo khác nhau (vd: tuổi, thu nhập) → gradient lệch, cần learning rate rất nhỏ → huấn luyện chậm.

Giải pháp:
Chuẩn hóa dữ liệu về cùng thang đo:

$$ x' = \frac{x - x_{\text{mean}}}{x_{\text{max}} - x_{\text{min}}} $$

Kết quả:
Gradient cân bằng hơn → có thể dùng learning rate lớn hơn → hội tụ nhanh & ổn định.

2️⃣ Regularization (Điều chuẩn hóa)

Vấn đề:
Khi các feature có đa cộng tuyến, trọng số (w) có thể rất lớn và không ổn định.

Giải pháp:
Thêm một thành phần "phạt" để kiểm soát độ lớn trọng số — gọi là L2 Regularization (Ridge).

$$ L(w_1, w_2, b) = (\hat{y} - y)^2 + \lambda(w_1^2 + w_2^2) $$

Kết quả:
Trọng số nhỏ hơn → mô hình ổn định, tổng quát hóa tốt hơn.

1.11 Đào sâu về Regularization

🔹 1. Giới thiệu L1 Regularization (Lasso)

Khác với L2 phạt theo bình phương, L1 phạt theo giá trị tuyệt đối của trọng số.

$$ L = (\hat{y} - y)^2 + \lambda \sum_{i=1}^{n} |w_i| $$

➡️ Sự thay đổi nhỏ này dẫn đến kết quả rất khác biệt.

🔹 2. 🥊 L1 (Lasso) vs. L2 (Ridge)

🔹 3. Vì sao L1 có thể chọn lọc đặc trưng?

• Vùng hình thoi (L1) có góc nhọn trên trục → lời giải tối ưu dễ "chạm" vào đó → một số trọng số = 0.
• Vùng hình tròn (L2) không có góc → trọng số chỉ bị kéo gần 0, không triệt tiêu.

➡️ L1 khuyến khích nghiệm thưa (sparse solution) → loại bỏ các feature không quan trọng.

🔹 4. Elastic Net — Kết hợp cả hai

Elastic Net kết hợp L1 + L2 Regularization, giúp:
- Ổn định mô hình (như L2).
- Chọn lọc đặc trưng (như L1).

🧭 Tổng kết

2. Data Version Control and FEAST

PHẦN 1: Giới thiệu về Data Version Control

1. Giới thiệu sơ lược về Machine Learning Operation

Vòng đời Machine Learning Operation (MLOps) bao gồm các giai đoạn chính:

• Thu thập và chuẩn bị dữ liệu: Giai đoạn đầu tiên trong quy trình, bao gồm việc thu thập dữ liệu từ nhiều nguồn khác nhau, làm sạch và chuẩn bị dữ liệu cho việc huấn luyện mô hình.
• Phát triển và huấn luyện mô hình: Xây dựng các mô hình machine learning, thử nghiệm các thuật toán khác nhau và huấn luyện mô hình trên tập dữ liệu đã chuẩn bị.
• Đánh giá và kiểm thử: Đánh giá hiệu suất của mô hình thông qua các metrics phù hợp, kiểm tra tính chính xác và độ tin cậy của mô hình.
• Triển khai (Deployment): Đưa mô hình vào môi trường production để phục vụ người dùng cuối hoặc các hệ thống khác.
• Giám sát và bảo trì: Theo dõi hiệu suất của mô hình trong thực tế, phát hiện các vấn đề như model drift, và thực hiện cập nhật khi cần thiết.
• Tái huấn luyện: Khi phát hiện hiệu suất mô hình giảm sút, thực hiện huấn luyện lại với dữ liệu mới để duy trì độ chính xác.

Phân tích Mô hình Data Versioning

Mô hình Data Versioning trong hình minh họa trên cho thấy quy trình quản lý phiên bản dữ liệu và mô hình trong MLOps, bao gồm các thành phần chính:

1. Repository Structure (Cấu trúc Repository)

• Git Repository: Lưu trữ mã nguồn, metadata, và các file cấu hình (.dvc files) - những file nhỏ chứa thông tin về dữ liệu thực tế.
• Remote Storage: Nơi lưu trữ dữ liệu và mô hình thực tế (có thể là S3, Google Cloud Storage, Azure Blob, hoặc local storage).

2. Workflow Process (Quy trình làm việc)

• Data Addition (dvc add): Khi thêm dữ liệu mới, DVC tạo ra file .dvc chứa checksum và metadata, trong khi dữ liệu thực được lưu vào remote storage.
• Version Control: Git quản lý các file .dvc, cho phép tracking các thay đổi về dữ liệu qua từng commit.
• Data Retrieval (dvc pull): Khi cần làm việc với phiên bản dữ liệu cụ thể, sử dụng lệnh pull để tải về từ remote storage.

3. Lợi ích của Mô hình này

• Tách biệt Code và Data: Git repository nhẹ, không chứa dữ liệu lớn, chỉ chứa metadata.
• Reproducibility: Có thể tái tạo chính xác bất kỳ phiên bản nào của dữ liệu và mô hình.
• Collaboration: Nhiều thành viên có thể làm việc đồng thời mà không gặp xung đột về dữ liệu lớn.
• Storage Efficiency: Chỉ lưu trữ sự khác biệt giữa các phiên bản, tiết kiệm không gian.

4. Quy trình Hoạt động Cụ thể

1. Developer thêm/sửa dữ liệu: Chạy dvc add data/dataset.csv
2. DVC tạo file .dvc: File này chứa hash và metadata của dữ liệu
3. Push dữ liệu lên remote: dvc push để upload dữ liệu thực tế
4. Commit metadata vào Git: git add data/dataset.csv.dvc && git commit
5. Team member khác pull: git pull && dvc pull để đồng bộ cả code và data

Data Version Control (DVC) đóng vai trò quan trọng trong việc quản lý dữ liệu và mô hình xuyên suốt vòng đời này, giúp đảm bảo tính tái tạo (reproducibility) và khả năng theo dõi các thay đổi trong quá trình phát triển ML.

1. Một số cơ bản về Data Version Control

• Là một nền tảng khoa học dữ liệu nằm trên đỉnh của ngăn xếp nguồn mở
• Một số nền tảng DVC phổ biến:
  • DVC (Data Version Control): Công cụ mã nguồn mở phổ biến nhất, tích hợp tốt với Git, hỗ trợ nhiều remote storage như S3, Google Drive, Azure.
  • Git LFS (Large File Storage): Giải pháp của GitHub để quản lý các file lớn, thay thế các file lớn bằng text pointers trong Git.
  • Pachyderm: Nền tảng data versioning và data pipeline mạnh mẽ, được thiết kế đặc biệt cho ML workflows.
  • LakeFS: Cung cấp Git-like operations cho data lakes, hỗ trợ versioning cho dữ liệu quy mô lớn.
  • Delta Lake: Lớp storage mở rộng được xây dựng trên data lakes, cung cấp ACID transactions và data versioning.
  • MLflow: Nền tảng quản lý ML lifecycle, bao gồm cả khả năng tracking và versioning cho
• Cách cài đặt: $pip install dvc
• Một số lệnh cơ bản: dvc add, dvc run, dvc repo, dvc remote

Thực hành trên ứng dụng

Link repo: https://github.com/NhanTrannn/DVC_Learning_Project

Hướng dẫn các bước thực hành:

Step 1: Set up project

1. Tạo folder chứa project

mkdir dvc-mnist-demo
cd dvc-mnist-demo

2. Tạo nhánh cây cho dự án

mkdir -p data/raw data/processed models scripts

3. Tạo môi trường Python / cài thư viện

Đối với conda env:

conda create -n dvc_mnist python=3.11
conda activate dvc_mnist

Đối với venv (Windows PowerShell):

python -m venv .venv
.\.venv\Scripts\Activate.ps1

File requirements.txt (tham khảo):

dvc==3.63.0
tensorflow==2.20.0
pandas==2.2.2
numpy
scikit-learn==1.7.2
matplotlib==3.10.6
dvc-s3==3.2.2

4. Khởi tạo Git repository

git init
git add .
git commit -m "Init project"

5. Chạy script download dữ liệu

python scripts/download_v1.py

6. Thiết lập DVC

dvc init
dvc add data/raw/x_train_v1.npy data/raw/y_train_v1.npy data/raw/x_test.npy data/raw/y_test.npy

7. Tạo symbolic link (Windows)

mklink x_train.npy x_train_v1.npy
mklink y_train.npy y_train_v1.npy

8. Thêm các artifact khác do DVC quản lý

dvc add models/model.npy
dvc add models/metrics.json

9. Tạo local DVC storage và cấu hình remote mặc định

mkdir dvc_storage
dvc remote add -d localremote ./dvc_storage

Ghi chú: để dùng remote cloud (ví dụ AWS S3) bạn cần tạo tài khoản S3 và cấu hình quyền truy cập (AWS credentials) theo hướng dẫn DVC.

10. Đẩy dữ liệu lên remote

dvc push

Lệnh này sẽ đọc file .dvc và đẩy nội dung dữ liệu lớn từ local cache lên remote (ví dụ localremote hoặc S3).

11. Lấy dữ liệu về (khi hợp tác)

git clone <your-repository>
dvc pull

Ghi chú: khi clone repository, cộng tác viên chỉ nhận được code và các file .dvc (nhỏ). Sau khi chạy dvc pull, DVC sẽ tải dữ liệu lớn từ remote storage về máy họ.

Sử dụng lại data version cũ

• Bước 1: git checkout <commit_id_cu>. Lệnh này thay đổi code và quan trọng hơn là thay đổi các file .dvc về phiên bản cũ.
• Bước 2: dvc checkout. Lệnh này nhìn vào các file .dvc hiện tại và tự động kéo các file dữ liệu lớn (từ 2 tuần trước) từ cache về, ghi đè lên các file hiện tại.

*NOTE:

• File dvc.yaml: Thay vì chạy các file train.py, evaluate.py bằng tay, bạn định nghĩa chúng thành các giai đoạn (stages) trong file dvc.yaml. Bạn khai báo rõ: giai đoạn này (stage) dùng code nào, phụ thuộc (deps) vào data nào, và tạo ra (outs) kết quả gì.
• File params.yaml: Đây là nơi bạn lưu trữ các siêu tham số (hyperparameters) như learning_rate, epochs.... DVC cũng theo dõi file này.
• Lệnh dvc repro: Đây là lệnh "thần thánh". Khi bạn chạy dvc repro, DVC sẽ tự động:
  1. Kiểm tra xem có gì thay đổi không (code, data, hay params).
  2. Nếu có, nó sẽ tự động chạy lại các giai đoạn cần thiết. Nếu không có gì thay đổi, nó sẽ không làm gì cả. Điều này đảm bảo pipeline của bạn luôn được tái tạo một cách chính xác.
• Theo dõi kết quả:
  • dvc metrics show: Hiển thị các chỉ số (ví dụ: accuracy) mà bạn đã định nghĩa trong pipeline.
  • dvc params diff: So sánh sự thay đổi về tham số giữa commit hiện tại và commit trước.
  • dvc metrics diff: So sánh kết quả (metrics) giữa các thử nghiệm khác nhau
• Git Workflow: Là quy trình mà các lập trình viên đã quen thuộc, với các nhánh (branch) như master, dev, feature để quản lý các tính năng của code.
• Data Workflow: Là một quy trình song song do DVC quản lý. Bạn có thể tạo các "nhánh dữ liệu" (ví dụ: thử nghiệm datasetb mới, hoặc thử nghiệm tham số change_mask_rate).

Phần 2: FEAST

1. Machine Learning Project Cycle

1. Data Ingestion (Thu thập dữ liệu): Giai đoạn đầu vào, nơi dữ liệu được thu thập từ nhiều nguồn.
2. Data Preprocessing & Validation (Tiền xử lý & Xác thực dữ liệu): Dữ liệu thô được làm sạch, biến đổi và kiểm tra chất lượng.
3. Model Training (Huấn luyện mô hình): Sử dụng dữ liệu đã xử lý để huấn luyện mô hình ML.
4. Model Evaluation & Registry (Đánh giá & Đăng ký mô hình): Mô hình mới được đánh giá hiệu suất. Nếu đạt yêu cầu, nó sẽ được lưu trữ và đăng ký (ví dụ: trong một Model Registry).
5. Model Deployment (Triển khai mô hình): Mô hình đã được xác thực sẽ được triển khai lên môi trường production (ví dụ: dưới dạng một API).
6. Model Monitoring & Maintenance (Giám sát & Bảo trì mô hình): Hệ thống liên tục theo dõi hiệu suất của mô hình trong thực tế (phát hiện data drift, model drift) và thực hiện bảo trì khi cần thiết.

Chu trình này lặp lại liên tục để đảm bảo hệ thống luôn được cập nhật và duy trì hiệu suất.

2. Machine Learning project life cycle

Sơ đồ này mô tả vòng đời dự án ML qua 4 vai trò (quadrant) chính, tất cả đều xoay quanh một nền tảng Hạ tầng AI (AI Infrastructure) chung.

Một dự án ML bắt đầu với dữ liệu và mục tiêu là huấn luyện mô hình để triển khai. Sau đó, các mô hình này phải được giám sát và đánh giá liên tục.

1. Data Engineering (Kỹ thuật dữ liệu):
   • Các kỹ sư dữ liệu chuẩn bị và biến đổi dữ liệu thô thành định dạng có thể sử dụng được.
   • Công việc bao gồm: Định nghĩa yêu cầu dữ liệu , thu thập , kiểm tra, làm sạch, gán nhãn , xây dựng pipeline và theo dõi dữ liệu (tracing).
2. Modeling (Xây dựng mô hình):
   • Các chuyên gia (Modeling specialists) phân tích dữ liệu để tìm ra các mẫu (pattern) giúp dự đoán kết quả, xác định rủi ro, cơ hội và hiểu mối quan hệ nhân-quả.
   • Công việc bao gồm: Huấn luyện mô hình ML , định nghĩa thước đo đánh giá , tìm kiếm siêu tham số (hyperparameters) , và tăng tốc thời gian dự đoán.
3. Deployment (Triển khai):
   • Các kỹ sư triển khai tích hợp mô hình với các luồng dữ liệu trực tiếp, kiểm thử hệ thống và đảm bảo mọi thứ hoạt động chính xác trước khi phát hành.
   • Công việc bao gồm: Chuyển đổi code prototype sang production , xây dựng API , huấn luyện lại mô hình (retraining) , và kiểm soát phiên bản (version control).
4. Business Analysis (Phân tích nghiệp vụ):
   • Các nhà phân tích nghiệp vụ đánh giá hiệu suất và tác động kinh doanh của mô hình đã triển khai, thực hiện các điều chỉnh để tối đa hóa giá trị.
   • Công việc bao gồm: Xây dựng dashboard , chạy thử nghiệm A/B test , và "dịch" các kết quả thống kê thành các thông tin chi tiết có giá trị cho kinh doanh.

2. Quy trình Machine Learning

• Giai đoạn "Experiment" (Thử nghiệm):
  • Đây là "hành trình khởi đầu" của một hệ thống ML, thường diễn ra trong môi trường linh hoạt như Jupyter Notebook.
  • Các Data Scientist thực hiện Feature Processing (Offline) trên một tập dữ liệu lịch sử (Data).
  • Họ có thể nhanh chóng xử lý dữ liệu, thiết kế đặc trưng phức tạp và huấn luyện mô hình đạt độ chính xác cao.
  • Trong quy trình ML học thuật/thử nghiệm, các bước này thường là: (1) Thu thập/xử lý dữ liệu, (2) Xử lý đặc trưng, (3) Huấn luyện/đánh giá, (4) Triển khai (thường chỉ là demo).
• Giai đoạn "Serving" (Vận hành/Phục vụ):
  • Đây là giai đoạn ứng dụng mô hình vào thực tế để tạo ra giá trị kinh doanh.
  • Hệ thống nhận dữ liệu mới (New data) và phải thực hiện Feature Processing (Online) —tức là tái hiện lại logic xử lý đặc trưng—nhưng lần này là trong thời gian thực với độ trễ thấp.
  • Sau đó, mô hình thực hiện Dự đoán (Predict) cho người dùng (User)

2. Training-Serving Skew

Mọi vấn đề đều bắt đầu từ đây. "Training-Serving Skew" là hiện tượng hiệu suất mô hình sụt giảm trên thực tế do sự khác biệt trong logic xử lý đặc trưng (feature processing logic) giữa môi trường huấn luyện (training) và môi trường phục vụ (serving).

• Khi Huấn luyện (Offline): Bạn có thể viết một đoạn mã Python phức tạp trong notebook để tính "số lượng giao dịch trung bình của người dùng A trong 30 ngày qua". Bạn chạy nó trên một tập dữ liệu lịch sử khổng lồ (batch processing).
• Khi Phục Vụ (Online): Khi người dùng A thực hiện một giao dịch ngay bây giờ, hệ thống của bạn phải tính chính xác đặc trưng đó trong... vài mili giây (real-time serving).

Việc đảm bảo logic tính toán ở hai môi trường này giống hệt nhau là cực kỳ khó khăn. Một sai lệch nhỏ (ví dụ: cách bạn xử lý giá trị null, làm tròn số) sẽ tạo ra "feature mismatch" (sai lệch đặc trưng), và mô hình của bạn sẽ đưa ra dự đoán sai.

2. Feature Store là gì?

Để xử lí Training-Serving Skew, cộng đồng MLOps đã phát minh ra Feature Store.

Đây không chỉ là một cái cơ sở dữ liệu. Theo định nghĩa chuyên ngành, Feature Store là một hệ thống trung tâm để quản lý, lưu trữ và cung cấp các đặc trưng (features) một cách nhất quán cho cả việc huấn luyện mô hình và dự đoán thời gian thực.

Nó đóng vai trò là cầu nối quan trọng giữa Data Engineering (người tạo ra dữ liệu) và Data Science (người sử dụng dữ liệu).

3. Feature Store (Kiến trúc cốt lõi)

Bài học đã phân tích rất rõ ba thành phần cốt lõi của một Feature Store hiện đại:

1. Offline Store (Kho lưu trữ Ngoại tuyến):
   • Mục đích: Lưu trữ dữ liệu lịch sử của các đặc trưng.
   • Công dụng: Được tối ưu để truy vấn các tập dữ liệu cực lớn nhằm mục đích huấn luyện mô hình hoặc phân tích.
   • Công nghệ: Thường là các Data Warehouse (như BigQuery) hoặc Data Lake (như file Parquet).
2. Online Store (Kho lưu trữ Trực tuyến):
   • Mục đích: Chỉ lưu trữ giá trị mới nhất của các đặc trưng.
   • Công dụng: Được tối ưu cho việc truy vấn với độ trễ cực thấp (low-latency) để phục vụ dự đoán thời gian thực.
   • Công nghệ: Thường là các cơ sở dữ liệu Key-Value tốc độ cao (như Redis, DynamoDB).
3. Registry (Sổ đăng ký):
   • Mục đích: Đây là "bộ não" hay "bản đồ" của Feature Store.
   • Công dụng: Lưu trữ và quản lý metadata (siêu dữ liệu) về tất cả các định nghĩa đặc trưng, các thực thể (entities), nguồn dữ liệu (data sources) và logic biến đổi. Đây chính là "nguồn chân lý duy nhất" (single source of truth) định nghĩa các đặc trưng của bạn.

4. Feast

Bài học tập trung vào Feast , một trong những Feature Store mã nguồn mở phổ biến nhất. Feast cung cấp các "khối xây dựng" (objects) chuyên ngành để bạn định nghĩa hệ thống của mình:

• Entity (Thực thể): Đối tượng kinh doanh mà bạn đang mô tả. Đây là "khóa kết nối" (join key). Ví dụ: customer_id, product_id.
• DataSource (Nguồn dữ liệu): Cho Feast biết dữ liệu thô của bạn đến từ đâu (ví dụ: một file Parquet trong S3, một bảng BigQuery).
• FeatureView (Khung nhìn Đặc trưng): Đây là khái niệm quan trọng nhất. Nó là một đơn vị logic kết hợp Entity, DataSource và các Features lại với nhau. Nó định nghĩa cách biến đổi dữ liệu thô thành các đặc trưng sẵn sàng cho mô hình.
• FeatureService (Dịch vụ Đặc trưng): Định nghĩa một tập hợp các FeatureView được sử dụng cùng nhau cho một mô hình cụ thể.

5. Hai Câu Lệnh Giải Quyết Mọi Vấn Đề

Đây là phần kiến thức chuyên sâu nhất, cho thấy cách Feast giải quyết bài toán Training-Serving Skew. Feast cung cấp hai phương thức phục vụ (serving) chính:

1. store.get_historical_features() (Lấy đặc trưng lịch sử):
   • Dùng để: Huấn luyện mô hình.
   • Cách hoạt động: Nó truy vấn vào Offline Store để lấy một tập dữ liệu lớn.
   • Siêu năng lực (Chuyên ngành): Nó đảm bảo "Point-in-time Correctness" (Tính chính xác tại thời điểm). Nghĩa là, khi bạn tạo dữ liệu huấn luyện, Feast đảm bảo chỉ lấy các giá trị đặc trưng trước thời điểm sự kiện (ví dụ: transaction_timestamp) xảy ra. Điều này tự động giúp bạn tránh rò rỉ dữ liệu (data leakage) từ tương lai, một lỗi cực kỳ nghiêm trọng trong Machine Learning.
2. store.get_online_features() (Lấy đặc trưng trực tuyến):
   • Dùng để: Dự đoán thời gian thực (Inference).
   • Cách hoạt động: Nó truy vấn vào Online Store để lấy giá trị mới nhất của một vector đặc trưng cho một (hoặc vài) entity cụ thể (ví dụ: customer_id = 123).
   • Siêu năng lực: Tốc độ cực nhanh, độ trễ thấp.

6. Cầu Nối Giữa Offline và Online: Materialization

Bạn có thể thắc mắc: "Làm thế nào dữ liệu từ Offline Store (lịch sử) có thể xuất hiện trong Online Store (mới nhất)?"

Câu trả lời là quá trình Materialization (Hiện thực hóa).

Đây là một câu lệnh chuyên dụng của Feast (feast materialize). Nó thực hiện công việc tính toán các giá trị đặc trưng từ Offline Store và nạp (load) chúng vào Online Store để sẵn sàng cho việc phục vụ với độ trễ thấp. Quá trình này thường được lên lịch chạy (ví dụ: mỗi giờ một lần) để giữ cho Online Store luôn được cập nhật.

3. Giải thuật LIME và ANCHOR trong XAI

1. Giới thiệu

AI ngày càng hiện diện sâu trong đời sống — từ trợ lý ảo như ChatGPT đến xe tự hành.
Nhưng phần lớn các mô hình hiện nay là “hộp đen” (black box): ta đưa đầu vào, nhận đầu ra, mà không hiểu vì sao mô hình ra quyết định như vậy.

Điều này đặc biệt nguy hiểm trong lĩnh vực:
- Y tế: chẩn đoán sai có thể gây hậu quả nghiêm trọng.
- Tư pháp: mô hình như COMPAS từng bị phát hiện có thiên vị chủng tộc.
- Tài chính: dự đoán sai rủi ro tín dụng có thể gây thiệt hại lớn.

→ Từ đó, lĩnh vực XAI (Explainable AI) ra đời, hướng đến việc tạo ra mô hình có thể giải thích được.

2. Hai khái niệm cốt lõi

Interpretability

Khả năng hiểu trực tiếp cơ chế hoạt động của mô hình.

Ví dụ: mô hình hồi quy tuyến tính

$$ y = w_1x_1 + w_2x_2 + b $$

Ta có thể đọc trọng số $w_1, w_2$ để biết đặc trưng nào ảnh hưởng mạnh hơn.

Explainability

Giúp giải thích tại sao mô hình (dù phức tạp) đưa ra quyết định.
Không cần hiểu cơ chế bên trong, chỉ cần hiểu lý do của kết quả.

Ví dụ: trong mạng CNN nhận diện khuôn mặt, ta chỉ biết vùng nào của khuôn mặt ảnh hưởng đến quyết định “đây là A” — dù không hiểu được từng trọng số trong mạng.

3. Hiệu suất và khả năng diễn giải

Có một sự đánh đổi giữa:
- Mô hình đơn giản → dễ hiểu nhưng hiệu suất thấp
- Mô hình phức tạp → mạnh mẽ nhưng mờ đục

4. Phân loại các phương pháp XAI

5. Thuật toán LIME (Local Interpretable Model-Agnostic Explanations)

Ý tưởng

Thay vì hiểu toàn bộ mô hình phức tạp, LIME chỉ tập trung một vùng nhỏ quanh điểm cần giải thích, rồi dùng một mô hình tuyến tính đơn giản để xấp xỉ hành vi của mô hình tại đó.

Quy trình

1. Tạo dữ liệu lân cận (perturbation) quanh điểm cần giải thích.
2. Dự đoán đầu ra cho các điểm này bằng mô hình gốc.
3. Tính khoảng cách giữa điểm giả và điểm gốc:

$$ d_i = 1 - \text{cosine\_similarity}(X_{\text{original}}, X_i) $$

4. Gán trọng số dựa theo khoảng cách:

$$ w_i = \exp\left(-\frac{d_i^2}{2\sigma^2}\right) $$

5. Chọn đặc trưng quan trọng nhất (thường là top-m).
6. Huấn luyện mô hình tuyến tính đơn giản có trọng số $w_i$.
7. Phân tích hệ số để hiểu đặc trưng nào ảnh hưởng mạnh nhất.

Hạn chế của LIME

• Không ổn định: vì phụ thuộc vào lấy mẫu ngẫu nhiên.
• Chỉ cục bộ: không phản ánh hành vi toàn cục.
• Phụ thuộc tham số: $\sigma$, số lượng mẫu, phương pháp khoảng cách.
• Tốn thời gian tính toán.
• Khó biểu diễn dữ liệu phức tạp (ảnh, âm thanh, văn bản).

6. Thuật toán ANCHOR

Động lực

LIME giả định tính tuyến tính cục bộ — điều này không luôn đúng.
ANCHOR ra đời để xác định các quy tắc (rules) giúp mô hình duy trì cùng dự đoán với xác suất cao.

Định nghĩa

Một anchor $A$ là tập điều kiện sao cho:

$$ prec(A) = \mathbb{E}_{D(z|A)} [\mathbf{1}_{f(x)=f(z)}] $$

và ta yêu cầu:

$$ P(prec(A) \geq \tau) \geq 1 - \delta $$

• $\tau$: ngưỡng độ chính xác mong muốn
• $\delta$: mức sai số chấp nhận được
• Độ bao phủ (coverage):

$$ cov(A) = \mathbb{E}_{D(z)}[A(z)] $$

→ Bài toán tối ưu:

$$ \max_A \quad cov(A) \quad \text{s.t.} \quad P(prec(A) \ge \tau) \ge 1 - \delta $$

Quy trình

1. Sinh luật ứng viên (predicates): ví dụ “Age > 30”, “Sex = Male”.
2. Tạo dữ liệu lân cận thỏa các điều kiện của anchor.
3. Dự đoán bằng mô hình gốc, ghi nhận mẫu nào cùng nhãn.
4. Tính độ chính xác và độ bao phủ:

$$ prec(A) = \frac{\text{\# mẫu cùng dự đoán}}{\text{\# mẫu thỏa anchor}} $$

$$ cov(A) = \frac{\text{\# mẫu thỏa anchor}}{\text{\# mẫu trong tập kiểm tra}} $$

5. Thuật toán KL-LUCB chọn anchor có độ chính xác $\ge \tau$ và độ bao phủ lớn nhất.

Ví dụ (thu nhập cá nhân)

Mô hình:

IF các điều kiện trên THEN dự đoán Salary > 50K
Precision = 0.97, Coverage = 0.02

Ưu điểm so với LIME

• Cho lời giải thích dạng luật IF–THEN, dễ hiểu hơn.
• Có độ tin cậy định lượng ($prec(A)$, $cov(A)$).
• Ổn định và tái lập được.
• Không giả định tính tuyến tính cục bộ.

7. Kết luận

Tóm lại:
LIME giúp hiểu nhanh mô hình bằng xấp xỉ tuyến tính,
còn ANCHOR giúp hiểu chắc mô hình bằng luật có thể kiểm chứng.