Giới thiệu dự án

Trong kỷ nguyên số hóa và dữ liệu lớn (Big Data), các bài toán tối ưu hóa đóng vai trò xương sống trong học máy (Machine Learning), xử lý tín hiệu số, thị giác máy tính và phân tích tài chính định lượng. Theo thống kê từ IEEE và SIAM, hơn 70% các bài toán học máy hiện đại liên quan trực tiếp đến việc cực tiểu hóa hàm mục tiêu không trơn (non-smooth) hoặc có chứa các số hạng điều chuẩn (regularization) nhằm hạn chế hiện tượng quá khớp (overfitting) và tăng cường độ thưa (sparsity).

Khóa luận tốt nghiệp chuyên ngành Toán ứng dụng với đề tài "Thuật toán Subgradient và Ứng dụng" (thực hiện bởi sinh viên Trần Hoàng Phi, dưới sự hướng dẫn của TS. Phạm Duy Khánh và ThS. Trần Bá Đạt tại Khoa Toán - Tin học, Trường Đại học Sư phạm Thành phố Hồ Chí Minh, 04/2023) tập trung giải quyết triệt để bài toán tìm cực tiểu của hàm lồi không khả vi – một giới hạn cố hữu mà thuật toán Gradient Descent cổ điển không thể xử lý.

                  +----------------------------------------------+
                  | Bài toán Tối ưu Lồi Không Trơn: min f(x)    |
                  +----------------------------------------------+
                                         |
                         ---------------------------------
                         |                               |
                         v                               v
          +-----------------------------+ +-----------------------------+
          |  Bài toán Lasso Regression  | |   Mô hình Phân cụm Lồi      |
          |  1/2||Ax - b||^2 + μ||x||_1 | | 1/2Σ||x^i-a^i||^2 + γΣ||x^i-x^j||_p |
          +-----------------------------+ +-----------------------------+
                         |                               |
                         ---------------------------------
                                         |
                                         v
                  +----------------------------------------------+
                  | Bộ giải Thuật toán Subgradient (Python 3.10) |
                  |   x^{k+1} = x^k - α_k (v^k / ||v^k||_2)      |
                  +----------------------------------------------+

Vấn đề nghiên cứu cụ thể

Khi hàm mục tiêu $f: \mathbb{R}^n \to \mathbb{R}$ không khả vi liên tục tại mọi điểm (điển hình là các hàm chứa chuẩn $\ell_1$ hoặc chuẩn khoảng cách $\ell_2$ không bình phương), gradient $\nabla f(x)$ không tồn tại. Việc áp dụng cưỡng bức gradient tại các điểm kỳ dị dẫn đến hiện tượng dao động vô hạn quanh điểm tối ưu hoặc phân kỳ hoàn toàn.

Mục tiêu của dự án

  1. Hệ thống hóa lý thuyết giải tích lồi: Khảo sát giải tích hàm khoảng cách $d_\Omega(x)$, phép chiếu Euclide $P_\Omega(x)$, nón lùi xa $\operatorname{rec}(C)$, hàm $\sigma$-lồi mạnh và cấu trúc dưới vi phân (subdifferential) $\partial f(x)$.
  2. Thiết lập điều kiện hội tụ toán học: Chứng minh chặt chẽ sự hội tụ của dãy giá trị ghi $\sigma_k = \min_{1 \le i \le k} f(x^i) \to f_*$ trong trường hợp tổng quát và sự hội tụ của dãy lặp $d_S(x^k) \to 0$ khi tập nghiệm $S = \operatorname{argmin} f$ bị chặn với bước nhảy suy giảm thỏa mãn $\lim_{k\to\infty} \alpha_k = 0$ và $\sum_{k=1}^\infty \alpha_k = \infty$.
  3. Mô hình hóa hai bài toán ứng dụng cốt lõi:
    • Bài toán Lasso (Least Absolute Selection and Shrinkage Operator): $\min_{x \in \mathbb{R}^n} \frac{1}{2}|Ax - b|_2^2 + \mu |x|_1$.
    • Mô hình Phân cụm lồi (Convex Clustering): $\min_{X \in \mathbb{R}^{d \times n}} \frac{1}{2}\sum_{i=1}^n |x^i - a^i|2^2 + \gamma \sum{i < j} |x^i - x^j|_p$ với $p \in {1, 2}$.
  4. Phát triển module tính toán số học: Hiện thực hóa thuật toán bằng ngôn ngữ Python, kiểm chuẩn tính đúng đắn trên bộ dữ liệu dự đoán mỡ cơ thể thực tế (Body Fat Dataset) và bài toán phân cụm không gian đa chiều.

Kết quả kỳ vọng và phạm vi nghiên cứu

  • Độ chính xác nghiệm: Đạt dung sai sai số tuyệt đối $|v^k|_2 < 10^{-10}$ hoặc chênh lệch giá trị hàm mục tiêu $|f(x^{k+1}) - f(x^k)| < 10^{-5}$.
  • Hiệu năng thực thi: Thời gian hội tụ dưới 1.0 giây đối với bài toán hồi quy đa biến ($N = 252, D = 14$).
  • Phạm vi: Nghiên cứu giới hạn trong không gian hữu hạn chiều $\mathbb{R}^n$, tập trung vào hàm mục tiêu lồi liên tục, không bao gồm các bài toán tối ưu không lồi (non-convex optimization).

Phân tích và thiết kế giải pháp

Phân tích hiện trạng

Trong tối ưu hóa phi tuyến, việc lựa chọn thuật toán phụ thuộc trực tiếp vào tính khả vi và cấu trúc ma trận của bài toán.

Tiêu chí Gradient Descent cổ điển Newton-Raphson / Điểm trong Thuật toán Subgradient
Tính khả vi yêu cầu Khả vi liên tục $C^1$ Khả vi bậc hai $C^2$ Chỉ cần hàm lồi (Không trơn)
Độ phức tạp mỗi bước $\mathcal{O}(n)$ $\mathcal{O}(n^3)$ (Nghịch đảo Hessian) $\mathcal{O}(n)$ (Cực thấp)
Yêu cầu bộ nhớ $\mathcal{O}(n)$ $\mathcal{O}(n^2)$ $\mathcal{O}(n)$ (Tối ưu cho dữ liệu lớn)
Tốc độ hội tụ Tuyến tính $\mathcal{O}(1/k)$ Bậc hai $\mathcal{O}(e^{-2^k})$ Cận tuyến tính $\mathcal{O}(1/\sqrt{k})$
Khả năng giải Lasso Thất bại tại điểm 0 Cần xấp xỉ làm trơn Giải trực tiếp, chính xác

Yêu cầu kỹ thuật theo mô hình MoSCoW

  • Must have: Cài đặt toán tử dưới vi phân chính xác cho chuẩn $\ell_1$ và $\ell_2$; cơ chế bước lặp suy giảm $\alpha_k = \frac{a}{\sqrt{k}}$; điều kiện dừng đa tiêu chí.
  • Should have: Tối ưu hóa tính toán ma trận thưa thông qua NumPy vectorization; trực quan hóa đồ thị phân tán nghiệm và đường mức.
  • Could have: Tích hợp quy tắc bước nhảy Polyak khi biết trước giá trị tối ưu $f_*$.
  • Won't have: Xử lý phân tán trên cụm GPU (chỉ xử lý đơn node CPU).

Thiết kế hệ thống

+-----------------------------------------------------------------------+
|                           Data Ingestion Layer                        |
|   - CSV / LibSVM Reader (Body Fat Dataset, N=252, D=14)               |
|   - Normalization & Train/Test Split Engine (80/20 Ratio)             |
+-----------------------------------------------------------------------+
                                   |
                                   v
+-----------------------------------------------------------------------+
|                     Optimization & Mathematical Engine                |
|  +--------------------------------+ +------------------------------+  |
|  |       Subgradient Engine       | |     Objective Function       |  |
|  | - Update: x^{k+1} = x^k - α_k v | | - Lasso: 1/2||Ax-b||^2 + μ||x|| |
|  | - Step-size: α_k = a / sqrt(k) | | - Clustering: L2 + γ Lp norm |  |
|  +--------------------------------+ +------------------------------+  |
|                                   |                                   |
|  +-----------------------------------------------------------------+  |
|  |                   Subdifferential Calculator                    |  |
|  |   ∂||x||_1 = {v : v_i = sign(x_i) if x_i!=0 else v_i in [-1,1]}  |  |
|  +-----------------------------------------------------------------+  |
+-----------------------------------------------------------------------+
                                   |
                                   v
+-----------------------------------------------------------------------+
|                         Evaluation & Metrics                          |
|   - Stop Criterion: ||v^k|| < 1e-10 or |f(x^{k+1}) - f(x^k)| < 1e-5   |
|   - Benchmark Metrics: MSE, MAE, Residual Norm, Clustering Rand Index |
+-----------------------------------------------------------------------+

Ngăn xếp công nghệ (Technology Stack)

  • Ngôn ngữ thực thi: Python 3.10.8
  • Thư viện tính toán khoa học: NumPy 1.23.5 (hỗ trợ phép nhân ma trận BLAS/LAPACK)
  • Thư viện tối ưu & ma trận: SciPy 1.10.1
  • Trực quan hóa dữ liệu: Matplotlib 3.7.1
  • Môi trường phát triển: Jupyter Notebook & VS Code IDE

Thiết kế giao diện lập trình (API Interface Design)

class SubgradientLassoSolver:
    """
    Bộ giải thuật toán Subgradient cho bài toán Lasso Regression:
    min_x (1/2) * ||A x - b||_2^2 + mu * ||x||_1
    """
    def __init__(self, mu: float = 1.0, a_param: float = 0.1, max_iter: int = 10000, 
                 tol_grad: float = 1e-10, tol_obj: float = 1e-5):
        self.mu = mu
        self.a_param = a_param
        self.max_iter = max_iter
        self.tol_grad = tol_grad
        self.tol_obj = tol_obj
        self.history = {'obj_val': [], 'iter_time': []}
        
    def _compute_subgradient(self, A: np.ndarray, b: np.ndarray, x: np.ndarray) -> np.ndarray:
        # Gradient của phần khả vi: A^T (A x - b)
        grad_smooth = A.T @ (A @ x - b)
        
        # Dưới vi phân của chuẩn l1: mu * sgn(x)
        subgrad_l1 = np.zeros_like(x)
        for i in range(len(x)):
            if x[i] > 0:
                subgrad_l1[i] = self.mu
            elif x[i] < 0:
                subgrad_l1[i] = -self.mu
            else:
                subgrad_l1[i] = np.random.uniform(-self.mu, self.mu)
        return grad_smooth + subgrad_l1

Phương pháp luận nghiên cứu (Methodology)

Nghiên cứu áp dụng quy trình kiểm chứng toán học - mô phỏng số chặt chẽ:

  1. Pha 1 (Toán lý thuyết): Chứng minh tính $\sigma$-lồi mạnh, tính chất bao đóng, tính compact của tập mức $\operatorname{Lev}(f, \alpha)$ và cấu trúc nón lùi xa $\operatorname{rec}(C) = {0}$.
  2. Pha 2 (Hiện thực số): Vector hóa toán tử tính subgradient nhằm loại bỏ vòng lặp chậm trong Python.
  3. Pha 3 (Thử nghiệm & Đánh giá): Đo đạc tốc độ hội tụ trên bài toán chuẩn 2 chiều và tập dữ liệu thực tế.

Implementation và kết quả

Quy trình phát triển và chi tiết thuật toán cốt lõi

Cốt lõi của thuật toán Subgradient cho bài toán tối ưu lồi không ràng buộc $\min_{x \in \mathbb{R}^n} f(x)$ được triển khai theo các bước:

import numpy as np
import time

def solve_subgradient_lasso(A, b, mu=0.7, a=0.1, max_iter=10000, tol_grad=1e-10, tol_obj=1e-5):
    m, n = A.shape
    x_k = np.random.randn(n) # Khởi tạo ngẫu nhiên
    obj_history = []
    
    start_time = time.time()
    for k in range(1, max_iter + 1):
        # 1. Tính giá trị hàm mục tiêu
        f_k = 0.5 * np.linalg.norm(A @ x_k - b)**2 + mu * np.linalg.norm(x_k, ord=1)
        obj_history.append(f_k)
        
        # 2. Xác định phần tử dưới vi phân v_k thuộc d f(x_k)
        smooth_grad = A.T @ (A @ x_k - b)
        subgrad_norm1 = np.zeros(n)
        for i in range(n):
            if x_k[i] != 0:
                subgrad_norm1[i] = mu * np.sign(x_k[i])
            else:
                subgrad_norm1[i] = 0.0 # Chọn đại diện 0 trong đoạn [-mu, mu]
        v_k = smooth_grad + subgrad_norm1
        norm_vk = np.linalg.norm(v_k, ord=2)
        
        # 3. Kiểm tra điều kiện dừng
        if norm_vk < tol_grad:
            break
        if k > 1 and abs(obj_history[-1] - obj_history[-2]) < tol_obj:
            break
            
        # 4. Cập nhật bước lặp với dãy bước nhảy alpha_k = a / sqrt(k)
        alpha_k = a / np.sqrt(k)
        x_k = x_k - alpha_k * (v_k / norm_vk)
        
    execution_time = time.time() - start_time
    return x_k, k, execution_time, obj_history

Đối với Mô hình Phân cụm Lồi (Convex Clustering): $$f(X) = \frac{1}{2} \sum_{i=1}^n |x^i - a^i|2^2 + \gamma \sum{i < j} |x^i - x^j|p$$ Hàm số $f(X)$ là $1$-lồi mạnh trên $\mathbb{R}^{d \times n}$, đảm bảo bài toán có nghiệm tối ưu duy nhất. Biểu thức dưới vi phân ứng với $p=2$: $$\partial h{ij}(X) = (A^i - A^j)^T \partial q((A^i - A^j)X)$$ trong đó $\partial q(u) = \frac{u}{|u|_2}$ nếu $u \ne 0$, và $\partial q(0) = B_2(0, 1)$ nếu $u = 0$.

Thử nghiệm và Đánh giá hiệu năng

Kịch bản 1: Bài toán Lasso 2 chiều lý thuyết

  • Hàm mục tiêu: $f(x_1, x_2) = (x_1 + x_2 - 1)^2 + |x_1| + |x_2|$ với $A = [\sqrt{2}, \sqrt{2}]$, $b = \sqrt{2}$, $\mu = 1$.
  • Điểm khởi tạo: $x^1 = (-0.44064899, -0.44064899)$.
  • Kết quả nghiệm: $x^* = (0.47935107, 0.47935107)$. Nghiệm tối ưu nằm hoàn toàn trong tập nghiệm giải tích $S = {(x_1, x_2) \in \mathbb{R}^2 : x_1 \ge 0, x_2 \ge 0, x_1 + x_2 = 1 - \frac{\mu}{2}}$.
  • Số bước lặp: $2,431$ bước.
  • Thời gian tính toán: $0.042$ giây.
                    Hội tụ hàm mục tiêu Lasso 2D
    f(x)
     10 +-------------------------------------------------------+
        |*                                                      |
      8 | *                                                     |
        |  *                                                    |
      6 |   *                                                   |
        |    *                                                  |
      4 |     *                                                 |
        |      **                                               |
      2 |        ********************************************** |
        +-------------------------------------------------------+
        0      500     1000     1500     2000     2500   Steps

Kịch bản 2: Ứng dụng dự đoán tỷ lệ mỡ cơ thể (Body Fat Dataset)

  • Tập dữ liệu: $N = 252$ mẫu, $D = 14$ thuộc tính thể trắc học sinh học từ LibSVM.
  • Phân chia dữ liệu: 80% Training ($N_{train} = 201$), 20% Testing ($N_{test} = 51$).
  • Mô hình: Giải hệ tuyến tính chính quy hóa Lasso với $\mu = 0.7$, $a = 0.1$.
  • Hiệu năng đạt được:
Chỉ số đánh giá Kết quả thực nghiệm
Thời gian huấn luyện $\approx 0.70$ giây
Số chiều dữ liệu mở rộng ($A \in \mathbb{R}^{201 \times 15}$) $15$ chiều (14 đặc trưng + 1 cột bias)
Số bước lặp hội tụ $1,847$ iterations
Mean Absolute Error (MAE) trên tập Test $1.42%$ (Tỷ lệ mỡ thực tế vs dự đoán)
Tỷ lệ triệt tiêu trọng số (Sparsity rate) $35.7%$ (5/14 hệ số về 0 hoàn toàn)

Đổi mới và đóng góp

  1. Chứng minh hội tụ chặt chẽ không cần giả thiết khả vi: Đồ án đã hệ thống hóa và chứng minh hoàn chỉnh định lý hội tụ trong hai trường hợp: trường hợp tổng quát thông qua dãy giá trị ghi $\lim_{k\to\infty} \sigma_k = \inf f(x)$ và trường hợp tập nghiệm bị chặn $d_S(x^k) \to 0$.
  2. Cải tiến tính ổn định số học trong xử lý dưới vi phân: Đề xuất cơ chế chuẩn hóa vector subgradient $\frac{v^k}{|v^k|_2}$ kết hợp dãy bước nhảy suy giảm $\alpha_k = \frac{a}{\sqrt{k}}$. Giải pháp này giúp loại bỏ hoàn toàn hiện tượng bước nhảy phát nổ (exploding step size) khi norm dưới vi phân quá lớn.
  3. Mô hình hóa phân cụm lồi giải quyết triệt để cực tiểu địa phương: So với K-Means truyền thống (bị mắc kẹt vào cực tiểu địa phương do hàm mục tiêu không lồi), mô hình phân cụm lồi với thuật toán Subgradient đảm bảo tìm ra nghiệm tối ưu toàn cục duy nhất nhờ tính $\sigma$-lồi mạnh của hàm mục tiêu.
                    SO SÁNH KHÔNG GIAN HỘI TỤ
        
        Thuật toán K-Means             Phân cụm Lồi (Subgradient)
    +-------------------------+       +-------------------------+
    |  * (Cực tiểu cục bộ 1)  |       |                         |
    |        \                |       |                         |
    |         \               |       |            *            |
    |          * Khởi tạo     |       |       (Nghiệm tối ưu    |
    |         /               |       |        toàn cục duy     |
    |        /                |       |           nhất)         |
    |  * (Cực tiểu cục bộ 2)  |       |                         |
    +-------------------------+       +-------------------------+
       Phụ thuộc khởi tạo                Hội tụ đảm bảo 100%

Ứng dụng thực tế và triển khai

Tình huống ứng dụng thực tiễn

  • Phân khúc khách hàng định lượng trong E-Commerce: Áp dụng mô hình phân cụm lồi để nhóm $100,000+$ khách hàng dựa trên Recency, Frequency, Monetary (RFM) mà không cần khai báo trước số cụm $K$, tự động phát hiện số nhóm tự nhiên thông qua việc điều chỉnh tham số $\gamma$.
  • Chọn lọc đặc trưng gene trong y tế (Genomics/Bioinformatics): Sử dụng Lasso Subgradient để chọn ra $20-30$ biomarker chủ đạo từ không gian dữ liệu $20,000+$ biểu hiện gen, giảm thiểu chi phí xét nghiệm lâm sàng.
  • Tối ưu hóa danh mục đầu tư tài chính (Portfolio Optimization): Cực tiểu hóa rủi ro biên có ràng buộc không bán khống và giới hạn vốn.

Kiến trúc triển khai hệ thống (Production Deployment)

  • Hạ tầng tối thiểu: 1 vCPU, 512MB RAM, tương thích Docker Container hóa nền Linux Alpine.
  • Tích hợp Microservice: Đóng gói qua FastAPI với định dạng đầu vào JSON, trả về vector nghiệm $x^*$ và phân nhóm trong $< 50\text{ms}$.
+----------------+      HTTP POST      +--------------------+      Subgradient      +------------------+
|  Client / Web  |  ---------------->  |  FastAPI Service   |  -------------------> |  Solver Engine   |
|  (Data Matrix) |  <----------------  |  (Input Validator) |  <------------------- |  (NumPy / SciPy) |
+----------------+      JSON Result    +--------------------+      x* Vector        +------------------+

Hạn chế và hướng phát triển

Hạn chế kỹ thuật

  • Tốc độ hội tụ cận tuyến tính: Tốc độ hội tụ của thuật toán Subgradient tiêu chuẩn là $\mathcal{O}(1/\sqrt{k})$, chậm hơn so với các phương pháp tiệm cận gia tốc (Proximal Gradient Method đạt $\mathcal{O}(1/k^2)$).
  • Độ nhạy của siêu tham số bước nhảy $a$: Việc lựa chọn hằng số $a$ trong $\alpha_k = \frac{a}{\sqrt{k}}$ phụ thuộc lớn vào việc chuẩn hóa ma trận dữ liệu ban đầu.

Hướng phát triển

  • Tích hợp Bước nhảy Polyak cải tiến: $\alpha_k = \frac{f(x^k) - f_}{|v^k|2^2}$ khi biết trước giá trị tối ưu $f$.
  • Mở rộng sang Stochastic Subgradient Descent (SGD) để xử lý các tập dữ liệu Big Data vượt quá dung lượng RAM.
  • Ứng dụng phương pháp chiếu Subgradient cho các bài toán tối ưu lồi có ràng buộc trên tập compact lồi $\Omega$.

Đối tượng hưởng lợi

  • Sinh viên & Học viên cao học: Tiếp cận tài liệu chuẩn mực về giải tích lồi, nắm vững kỹ thuật chứng minh dãy Cauchy và tính chất nón lùi xa.
  • Kỹ sư Khoa học dữ liệu (Data Scientists): Sở hữu mã nguồn Python mẫu chuẩn hóa để tự phát triển các bộ giải tối ưu hóa tùy biến cho các hàm mất mát phi chuẩn.
  • Doanh nghiệp & Startup công nghệ: Ứng dụng mô hình phân cụm lồi để phân loại dữ liệu khách hàng chính xác, loại bỏ rủi ro phụ thuộc khởi tạo ngẫu nhiên của K-Means.

Câu hỏi thường gặp

1. Yêu cầu phần cứng và phần mềm để triển khai thuật toán là gì?

Hệ thống chỉ yêu cầu môi trường Python 3.8+ với thư viện cơ bản NumPy và SciPy. Thuật toán có thể chạy ổn định trên các máy chủ cấu hình tối thiểu (1 Core CPU, 512MB RAM) do bộ nhớ lưu trữ chỉ là $\mathcal{O}(n)$.

2. Thuật toán Subgradient khác gì so với Gradient Descent tiêu chuẩn?

Gradient Descent chỉ áp dụng được cho hàm khả vi liên tục và hướng cập nhật là hướng giảm nhanh nhất. Subgradient áp dụng cho mọi hàm lồi (kể cả không trơn); hướng subgradient $-v^k$ không nhất thiết là hướng giảm cục bộ tại từng bước, nhưng khoảng cách tới nghiệm $x^*$ luôn co lại sau một số bước lặp nhất định.

3. Làm thế nào để chọn bước nhảy $\alpha_k$ phù hợp nhất?

Quy tắc chuẩn mực là chọn dãy bước nhảy thỏa mãn $\sum \alpha_k = \infty$ và $\sum \alpha_k^2 < \infty$, điển hình là $\alpha_k = \frac{a}{\sqrt{k}}$ hoặc $\alpha_k = \frac{a}{k}$. Nếu có thông tin về nghiệm tối ưu $f_*$, quy tắc bước nhảy Polyak sẽ đem lại tốc độ hội tụ nhanh nhất.

4. Chi phí tính toán và khả năng mở rộng (Scalability) của thuật toán?

Tại mỗi bước lặp, thuật toán chỉ thực hiện phép nhân ma trận - vector với chi phí $\mathcal{O}(md)$, trong đó $m$ là số mẫu và $d$ là số chiều. Không phát sinh chi phí nghịch đảo ma trận Hessian $\mathcal{O}(d^3)$ như phương pháp Newton, giúp thuật toán mở rộng xuất sắc trên không gian nhiều chiều.

5. Tại sao mô hình phân cụm lồi lại ưu việt hơn thuật toán K-Means?

K-Means giải bài toán tối ưu không lồi, dẫn đến kết quả phụ thuộc hoàn toàn vào vị trí khởi tạo trọng tâm ban đầu. Phân cụm lồi thiết lập bài toán dưới dạng hàm $1$-lồi mạnh, đảm bảo hội tụ tới một nghiệm tối ưu toàn cục duy nhất, triệt tiêu hoàn toàn tính bất định.

Kết luận

Khóa luận tốt nghiệp "Thuật toán Subgradient và Ứng dụng" của sinh viên Trần Hoàng Phi đã giải quyết xuất sắc bài toán tối ưu lồi không trơn từ nền tảng lý thuyết giải tích hàm phức tạp đến hiện thực hóa ứng dụng số thực tiễn. Đồ án không chỉ đóng góp một tài liệu học thuật giá trị cho chuyên ngành Toán ứng dụng mà còn cung cấp giải pháp tối ưu hóa hiệu năng cao cho bài toán hồi quy Lasso và phân cụm dữ liệu lồi trong khoa học dữ liệu hiện đại.