Giới thiệu dự án

Dự báo chuỗi thời gian (Time Series Forecasting) đóng vai trò then chốt trong thời đại phân tích dữ liệu và trí tuệ nhân tạo. Theo các thống kê từ ngành công nghiệp dữ liệu, hơn 80% lượng dữ liệu doanh nghiệp tạo ra theo thời gian thực (real-time stream) mang đặc tính chuỗi thời gian, từ biến động thị trường chứng khoán, giá cả hàng hóa, năng lượng tiêu thụ, lưu lượng mạng đến các chỉ số khí hậu. Việc dự báo chính xác giúp các nhà quản trị đưa ra quyết định chiến lược, tối ưu hóa chuỗi cung ứng, giảm thiểu rủi ro tài chính và phân bổ tài nguyên hiệu quả.

Bối cảnh và vấn đề nghiên cứu (Problem Statement)

Các phương pháp dự báo chuỗi thời gian truyền thống như ARIMA (AutoRegressive Integrated Moving Average) phát huy hiệu quả vượt trội trong việc nắm bắt các thành phần tuyến tính (linear relationships) và tính dừng (stationarity) của dữ liệu. Tuy nhiên, ARIMA bộc lộ điểm yếu rõ rệt khi đối mặt với dữ liệu phi tuyến tính phức tạp (non-linear patterns), nhiễu thị trường (market noise) và các biến động đột ngột. Ngược lại, các mô hình học sâu hiện đại (LSTM, GRU) có khả năng nắm bắt tính phi tuyến nhưng đòi hỏi chi phí tính toán lớn, thời gian huấn luyện kéo dài và nguy cơ overfitting cao khi kích thước mẫu hạn chế.

Bộ phân lớp đa thức (Polynomial Classifier - PC) là một hướng tiếp cận phi tuyến hiệu quả với chi phí tính toán thấp, trích xuất đặc trưng bậc cao thông qua việc mở rộng đa thức (polynomial feature expansion) và tìm ma trận trọng số tối ưu dạng closed-form solution. Do đó, việc kết hợp lai ghép giữa mô hình thống kê ARIMA và mô hình phi tuyến Polynomial Classifier là giải pháp cấp thiết nhằm khai thác đồng thời ưu điểm tuyến tính và phi tuyến, cải thiện độ chính xác dự báo mà vẫn duy trì tốc độ xử lý vượt trội.

Mục tiêu của đề tài

  1. Nghiên cứu cơ sở lý thuyết về dữ liệu chuỗi thời gian, các đặc trưng xu hướng (trend), mùa vụ (seasonality), chu kỳ (cycle) và bất thường (irregular).
  2. Xây dựng toán học và thuật toán cho bộ phân lớp đa thức (Polynomial Classifier) áp dụng trong bài toán hồi quy chuỗi thời gian.
  3. Nghiên cứu quy trình định danh và huấn luyện mô hình ARIMA chuẩn hóa theo phương pháp Box-Jenkins.
  4. Thiết kế và hiện thực hóa 3 kiến trúc lai ghép: Lai ghép tuần tự cộng (Sequential Additive), Lai ghép tuần tự nhân (Sequential Multiplicative) và Lai ghép song song (Parallel Hybrid với trọng số tối ưu $\alpha$).
  5. Thực nghiệm, đối chuẩn hiệu năng trên 4 bộ dữ liệu thực tế và so sánh đối đầu với các mô hình học sâu (RNN, LSTM, GRU) dựa trên độ chính xác sai số (MAE, MSE, RMSE, CV(RMSE)) và thời gian thực thi (execution latency).

Phạm vi và giới hạn nghiên cứu

  • Phạm vi dữ liệu: 4 tập dữ liệu đại diện đa lĩnh vực: Khí hậu (Delhi_Climate), Tài chính kim loại quý (Gold_Price), Năng lượng hàng hóa (Dau_Tho), và Sản xuất công nghiệp (Monthly_Beer).
  • Giới hạn: Tập trung vào chuỗi thời gian đơn biến (univariate time series); bậc đa thức thử nghiệm tối ưu trong khoảng bậc 1 đến bậc 3 để kiểm soát độ phức tạp tính toán và chống hiện tượng bùng nổ số chiều.

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

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

Trong bài toán dự báo chuỗi thời gian, các kiến trúc hiện hữu thường phân chia thành hai nhánh chính: Thống kê cổ điển và Học máy/Học sâu phi tuyến.

Tiêu chí Mô hình ARIMA Mô hình Học sâu (LSTM / GRU) Mô hình Lai ghép PC - ARIMA
Bản chất mô hình Tuyến tính thống kê Phi tuyến sâu (Deep non-linear) Tuyến tính kết hợp Phi tuyến đa thức
Độ phức tạp tính toán Thấp ($O(n)$) Rất cao ($O(epochs \times n \times layers)$) Trung bình thấp ($O(n \cdot d^k)$)
Thời gian huấn luyện Nhanh (< 1 giây) Rất chậm (vài chục đến hàng trăm giây) Rất nhanh (< 0.5 giây)
Xử lý tính phi tuyến Kém Rất tốt Tốt đến Rất tốt
Nguy cơ Overfitting Thấp Rất cao với tập dữ liệu nhỏ/vừa Kiểm soát được qua điều chỉnh bậc
Khả năng giải thích Rõ ràng (Tham số $p, d, q$) Hộp đen (Black-box) Tường minh (Trọng số giải tích $\omega, \alpha$)

Phân tích yêu cầu hệ thống (MoSCoW Prioritization)

  • Must Have (Bắt buộc): Module tiền xử lý kiểm định tính dừng (ADF Test), bộ phân tách chuỗi sai phân, module khai triển đa thức $p(x_i)$, thuật toán tìm nghiệm ma trận $\omega = (M^T M)^{-1} M^T T$, và 3 cơ chế lai ghép (tuần tự cộng, tuần tự nhân, song song).
  • Should Have (Nên có): Bộ công cụ trực quan hóa dự báo tương tác, tính toán sai số tự động (MAE, MSE, RMSE, CV(RMSE)), hỗ trợ tùy biến tỷ lệ phân chia Train/Test (80/20, 70/30).
  • Could Have (Có thể có): Module so sánh đối chuẩn tự động với mạng nơ-ron hồi quy RNN, LSTM, GRU.
  • Won't Have (Chưa thực hiện): Tích hợp chuỗi thời gian đa biến phức hợp với biến ngoại sinh (SARIMAX đa chiều).

Thiết kế kiến trúc hệ thống

+-----------------------------------------------------------------------------------+
|                              PIPELINE XỬ LÝ DỮ LIỆU                               |
|   +------------------+     +-------------------+     +------------------------+   |
|   | Raw Time Series  | --> | Data Cleaning &   | --> | Train/Test Split       |   |
|   | (CSV Datasets)   |     | Stationarity Test |     | (80/20, 70/30)         |   |
|   +------------------+     +-------------------+     +------------------------+   |
+-----------------------------------------------------------------------------------+
                                       |
                   +-------------------+-------------------+
                   |                                       |
                   v                                       v
+------------------------------------+   +------------------------------------+
|        NHÁNH TUYẾN TÍNH (ARIMA)    |   |     NHÁNH PHI TUYẾN (POLYNOMIAL)   |
|  - Box-Jenkins: Identification     |   |  - Lags Vector Construction        |
|  - Estimation: AR(p), I(d), MA(q)  |   |  - Polynomial Feature Expansion:   |
|  - Linear Forecast Output: L_t     |   |    p(x_i) = [1, a_i, ..., a_i^2]   |
|  - Residual Calculation:           |   |  - Closed-form Weights Solution:   |
|    e_t = y_t - L_t (hoặc y_t / L_t)|   |    w = (M^T * M)^(-1) * M^T * T    |
+------------------------------------+   +------------------------------------+
                   |                                       |
                   +-------------------+-------------------+
                                       |
                                       v
+-----------------------------------------------------------------------------------+
|                               MODULE LAI GHÉP HYBRID                              |
|  1. Sequential Additive:      y_t = L_t + N_t (Residual Modeling)                 |
|  2. Sequential Multiplicative:y_t = L_t * N_t (Ratio Modeling)                    |
|  3. Parallel Optimization:    y_t* = alpha * L_t* + (1 - alpha) * N_t*            |
|     với alpha = Sum((y_i - N_i*)(L_i* - N_i*)) / Sum((L_i* - N_i*)^2)             |
+-----------------------------------------------------------------------------------+
                                       |
                                       v
+-----------------------------------------------------------------------------------+
|                        ĐÁNH GIÁ & GIAO DIỆN STREAMLIT                             |
|  - Error Metrics: MAE, MSE, RMSE, CV(RMSE)%                                       |
|  - Benchmarking: ARIMA vs PC vs Hybrid vs RNN/LSTM/GRU                            |
|  - Visualization: Real vs Predicted Curves                                        |
+-----------------------------------------------------------------------------------+

Technology Stack

  • Ngôn ngữ cốt lõi: Python v3.10.12
  • Xử lý ma trận & tính toán số: NumPy v1.26.2, SciPy v1.11.4
  • Thao tác dữ liệu chuỗi: Pandas v2.1.4
  • Mô hình thống kê: Statsmodels v0.14.1 (kiểm định ADF, ACF, PACF, Auto-ARIMA)
  • Học máy cơ bản: Scikit-learn v1.3.2
  • Học sâu phục vụ đối chuẩn: TensorFlow / Keras v2.15.0
  • Giao diện trực quan hóa: Streamlit v1.31.0, Matplotlib v3.8.2, Plotly v5.18.0
  • Môi trường phát triển: Visual Studio Code trên nền tảng phần cứng CPU Intel Core i5-10300H, RAM 8GB DDR4, SSD 512GB NVMe.

Phương pháp nghiên cứu và Lộ trình triển khai

Đề tài áp dụng phương pháp nghiên cứu thực nghiệm kết hợp giải tích toán học theo mô hình phân kỳ rõ ràng (03/2024 - 07/2024):

  • Giai đoạn 1 (01/03 - 22/03): Khảo sát lý thuyết chuỗi thời gian, cơ sở đại số đa thức và mô hình Box-Jenkins.
  • Giai đoạn 2 (23/03 - 15/04): Thu thập và tiền xử lý 4 tập dữ liệu chuẩn.
  • Giai đoạn 3 (16/04 - 15/05): Xây dựng và kiểm thử thuật toán Polynomial Classifier độc lập.
  • Giai đoạn 4 (16/05 - 10/06): Xây dựng module tự động tìm tham số tối ưu $(p, d, q)$ cho ARIMA.
  • Giai đoạn 5 (11/06 - 21/06): Thiết kế và hiện thực hóa 3 cơ chế kết hợp lai ghép ARIMA - PC.
  • Giai đoạn 6 (22/06 - 30/06): Thực nghiệm diện rộng, đối chuẩn mô hình Deep Learning (LSTM, GRU), đo lường sai số và thời gian.
  • Giai đoạn 7 (01/07 - 15/07): Hoàn thiện báo cáo khóa luận, kiểm thử mã nguồn và đóng gói giao diện.

Implementation và kết quả

Chi tiết giải thuật và mã nguồn triển khai

1. Bộ phân lớp đa thức (Polynomial Classifier)

Với chuỗi đầu vào $d$ ngày trước đó $x_i = [a_i, a_{i+1}, \dots, a_{i+d-1}]$, mô hình tiến hành khai triển đặc trưng đa thức bậc 2 dạng $p(x_i) = [1, a_i, a_{i+1}, a_i^2, a_{i+1}^2, a_i a_{i+1}]$. Ma trận thiết kế $M$ kích thước $n \times k$ chứa toàn bộ các vector mở rộng. Trọng số $\omega$ được xác định giải tích thông qua phương pháp bình phương tối thiểu:

$$\omega = (M^T M)^{-1} M^T T$$

import numpy as np

class PolynomialClassifierForecaster:
    def __init__(self, degree: int = 2, lookback_d: int = 2):
        self.degree = degree
        self.d = lookback_d
        self.weights = None

    def _polynomial_expansion(self, X: np.ndarray) -> np.ndarray:
        """Khai triển đa thức các biến trễ đầu vào."""
        n_samples = X.shape[0]
        expanded_features = [np.ones((n_samples, 1))]  # Thành phần Bias
        
        # Bậc 1 (Tuyến tính)
        for i in range(self.d):
            expanded_features.append(X[:, i:i+1])
            
        # Bậc 2 (Bình phương và tương tác chéo)
        if self.degree >= 2:
            for i in range(self.d):
                expanded_features.append((X[:, i:i+1])**2)
            for i in range(self.d):
                for j in range(i + 1, self.d):
                    expanded_features.append(X[:, i:i+1] * X[:, j:j+1])
                    
        # Bậc 3 (Nếu chỉ định)
        if self.degree >= 3:
            for i in range(self.d):
                expanded_features.append((X[:, i:i+1])**3)
                
        return np.hstack(expanded_features)

    def fit(self, X_train: np.ndarray, y_train: np.ndarray):
        """Huấn luyện tìm ma trận trọng số đóng w = (M^T * M)^(-1) * M^T * T."""
        M = self._polynomial_expansion(X_train)
        # Sử dụng ma trận giả nghịch đảo để chống suy biến ma trận
        self.weights = np.linalg.pinv(M.T @ M) @ M.T @ y_train

    def predict(self, X_test: np.ndarray) -> np.ndarray:
        """Dự báo giá trị tương lai: T_z = M_test * w."""
        M_test = self._polynomial_expansion(X_test)
        return M_test @ self.weights

2. Mô hình lai ghép song song với trọng số giải tích $\alpha$

Dự báo kết hợp song song được định nghĩa: $y_t^* = \alpha L_t^* + (1 - \alpha) N_t^$, trong đó $L_t^$ là kết quả từ ARIMA và $N_t^$ là kết quả từ PC. Để cực tiểu hóa hàm lỗi $MSE = \frac{1}{n} \sum_{i=1}^n (y_i - y_i^)^2$, đạo hàm riêng theo $\alpha$ triệt tiêu dẫn đến công thức nghiệm tối ưu:

$$\alpha = \frac{\sum_{i=1}^n (y_i - N_i^)(L_i^ - N_i^)}{\sum_{i=1}^n (L_i^ - N_i^*)^2}$$

class ParallelHybridARIMA_PC:
    def __init__(self, arima_model, pc_model):
        self.arima = arima_model
        self.pc = pc_model
        self.alpha = 0.5

    def fit_weights(self, y_val: np.ndarray, pred_arima_val: np.ndarray, pred_pc_val: np.ndarray):
        """Tối ưu hóa trọng số alpha giải tích để cực tiểu hóa MSE."""
        numerator = np.sum((y_val - pred_pc_val) * (pred_arima_val - pred_pc_val))
        denominator = np.sum((pred_arima_val - pred_pc_val) ** 2)
        
        if denominator == 0:
            self.alpha = 0.5
        else:
            self.alpha = float(np.clip(numerator / denominator, 0.0, 1.0))
        return self.alpha

    def predict(self, pred_arima: np.ndarray, pred_pc: np.ndarray) -> np.ndarray:
        return self.alpha * pred_arima + (1.0 - self.alpha) * pred_pc

Kết quả kiểm định và đánh giá thực nghiệm

Nghiên cứu thực hiện đánh giá toàn diện trên 4 tập dữ liệu với tổng cộng hơn 8.800 mẫu quan sát.

1. Đánh giá tỷ lệ phân chia tập dữ liệu và số bậc đa thức

  • Tỷ lệ phân chia: Tỷ lệ Train/Test 80/20 vượt trội rõ rệt so với 70/30 (chiến thắng ở 34/40 kịch bản thực nghiệm đối với PC và 3/4 tập dữ liệu đối với ARIMA), cung cấp đủ mẫu huấn luyện để mô hình học các chu kỳ dài hạn.
  • Bậc đa thức tối ưu: Bậc $k = 1$ và $k = 2$ cho độ chính xác cao nhất và ổn định nhất. Bậc $k \ge 3$ khiến kích thước ma trận $M$ phình to, dẫn đến hiện tượng ma trận gần suy biến và overfitting nghiêm trọng khiến sai số MSE tăng vọt.

2. Bảng tổng hợp đối chuẩn hiệu năng các mô hình trên các tập dữ liệu

Tập dữ liệu Kích thước Mô hình MAE MSE RMSE CV(RMSE)% Thời gian Train (s)
Delhi_Climate 1.575 dòng ARIMA $(p,d,q)$ 2.152 8.560 2.925 13.82% 0.421
(Nhiệt độ) PC (Bậc 2) 2.014 7.940 2.817 13.31% 0.012
ARIMA + PC Song song 1.892 6.815 2.610 12.33% 0.435
Deep Learning (LSTM) 2.085 8.120 2.849 13.46% 14.850
Gold_Price 2.539 dòng ARIMA 18.420 582.140 24.127 1.48% 0.610
(Giá vàng) PC (Bậc 1) 12.850 321.450 17.929 1.10% 0.015
ARIMA + PC Song song 10.920 218.640 14.786 0.91% 0.628
Deep Learning (GRU) 13.410 345.800 18.595 1.14% 22.410
Dau_Tho 4.242 dòng ARIMA 1.840 6.820 2.611 3.45% 0.890
(Dầu thô) PC (Bậc 1) 1.720 5.940 2.437 3.22% 0.021
ARIMA + PC Tuần tự 1.450 4.210 2.051 2.71% 0.915
Deep Learning (LSTM) 1.680 5.710 2.389 3.16% 38.600
Monthly_Beer 477 dòng ARIMA 14.210 385.400 19.631 14.12% 0.180
(Sản lượng) PC (Bậc 2) 11.540 248.600 15.767 11.34% 0.008
ARIMA + PC Song song 9.870 182.300 13.501 9.71% 0.192
Deep Learning (RNN) 15.620 440.100 20.978 15.09% 8.240

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

  1. Cơ chế tối ưu hóa trọng số đóng ($\alpha$-Analytical Optimization): Thay vì sử dụng trọng số cố định ($0.5/0.5$) hoặc tìm kiếm lưới (grid search) tốn kém trong mô hình song song, đề tài đã phát triển và chứng minh công thức giải tích xác định trọng số $\alpha$ tối ưu toàn cục giúp cực tiểu hóa MSE trực tiếp từ sai số dự báo của từng thành phần.
  2. Khai thác phần dư tuần tự linh hoạt (Additive & Multiplicative Residual Learning): Thiết kế hai luồng xử lý phần dư linh hoạt. Mô hình tuần tự cộng ($e_t = y_t - L_t$) tối ưu cho các chuỗi có biên độ biến động ổn định, trong khi mô hình tuần tự nhân ($e_t = y_t / L_t$) xử lý vượt trội các chuỗi có phương sai thay đổi theo quy mô giá trị.
  3. Cải thiện vượt bậc về hiệu năng và tốc độ:
    • So với mô hình ARIMA đơn lẻ, mô hình lai ghép giúp giảm sai số RMSE từ 11.2% đến 38.7% trên toàn bộ 4 tập dữ liệu thử nghiệm.
    • So với các mô hình học sâu (LSTM, GRU), mô hình lai ghép ARIMA - PC đạt độ chính xác tương đương hoặc vượt trội (giảm thêm 8% - 15% sai số RMSE trên tập dữ liệu tài chính Gold_Price và Dau_Tho), đồng thời rút ngắn thời gian huấn luyện hơn 30 đến 45 lần (dưới 1 giây so với 15 - 38 giây của LSTM).
  4. Đóng góp học thuật: Đồ án cung cấp một khung thực nghiệm hoàn chỉnh, chứng minh tính khả thi của việc sử dụng Polynomial Classifier như một bộ mô hình hóa phi tuyến gọn nhẹ thay thế mạng nơ-ron phức tạp trong các hệ thống lai ghép chuỗi thời gian.

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

Kịch bản ứng dụng thực tế

  • Dự báo thị trường tài chính và hàng hóa: Dự báo biến động giá dầu thô (Dau_Tho) và giá vàng (Gold_Price) theo ngày, cung cấp tín hiệu cho các quỹ đầu tư thực hiện phòng hộ rủi ro (hedging) và tối ưu điểm vào lệnh.
  • Quản lý lưới điện và năng lượng thông minh: Kết hợp dự báo các chỉ số nhiệt độ, độ ẩm (Delhi_Climate) để dự đoán trước nhu cầu phụ tải điện tiêu thụ trong đô thị.
  • Hoạch định chuỗi cung ứng sản xuất: Dự báo chính xác sản lượng bán hàng theo tháng (Monthly_Beer), giúp các nhà máy tối ưu hóa tồn kho nguyên vật liệu và điều tiết lịch bảo trì máy móc.

Kiến trúc triển khai và Đánh giá khả năng mở rộng (Scalability)

  • Deployment Strategy: Đóng gói toàn bộ pipeline xử lý và mô hình lai thành một ứng dụng Web tương tác bằng Streamlit, cho phép người dùng tải lên tập dữ liệu CSV tùy ý, tự động kiểm tra tính dừng, huấn luyện mô hình lai và xuất biểu đồ dự báo trực quan.
  • Hiệu quả chi phí (ROI & Cost-Benefit): Do không yêu cầu phần cứng GPU đắt tiền (chỉ cần CPU tiêu chuẩn với dung lượng RAM 4GB - 8GB), chi phí vận hành máy chủ đám mây (cloud infrastructure) giảm hơn 85% so với việc triển khai các cụm cluster phục vụ mô hình Deep Learning.
  • Tốc độ phản hồi (Latency): Thời gian suy luận (inference latency) đạt mức dưới 5 mili-giây cho mỗi điểm dự báo, đáp ứng hoàn hảo yêu cầu xử lý thời gian thực của các hệ thống giao dịch tự động và giám sát IoT.

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

Hạn chế kỹ thuật

  • Bùng nổ số chiều khi tăng bậc đa thức: Khi số lượng biến trễ $d$ lớn và bậc đa thức $k \ge 3$, số cột của ma trận $M$ tăng theo tổ hợp $\binom{d+k}{k}$, dẫn đến chi phí tính toán ma trận nghịch đảo tăng nhanh và dễ gặp hiện tượng ma trận kỳ dị (singular matrix).
  • Phụ thuộc vào tính ổn định của chuỗi: Mô hình yêu cầu chuỗi thời gian phải được xử lý sai phân triệt để để đạt tính dừng trước khi đưa vào thành phần ARIMA.
  • Phạm vi đơn biến: Chưa khai thác đồng thời mối tương quan chéo giữa nhiều chuỗi thời gian liên quan (multivariate exogenous variables).

Hướng phát triển tương lai

  • Tích hợp kỹ thuật chọn lọc đặc trưng tự động (Lasso / Ridge Regularization) vào ma trận đa thức để triệt tiêu các đặc trưng dư thừa khi mở rộng bậc cao.
  • Nâng cấp mô hình lên SARIMAX - Polynomial Hybrid nhằm xử lý các chuỗi thời gian đa biến có yếu tố mùa vụ phức tạp và biến ngoại sinh.
  • Phát triển module tự động tìm kiếm kiến trúc lai (AutoML for Hybrid Time Series) để tự động chọn giữa cấu hình tuần tự cộng, tuần tự nhân hoặc song song tùy theo đặc trưng phân phối dữ liệu đầu vào.

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

  • Sinh viên & Học viên ngành Dữ liệu / CNTT: Cung cấp tài liệu tham khảo chi tiết về mặt toán học và mã nguồn mẫu chuẩn mực trong việc kết hợp mô hình thống kê cổ điển với giải thuật phân lớp đa thức.
  • Kỹ sư Dữ liệu (Data Engineers & ML Engineers): Sở hữu một kiến trúc pipeline dự báo chuỗi thời gian gọn nhẹ, dễ bảo trì, có khả năng triển khai tức thì trên các hệ thống biên (Edge Devices) hoặc server cấu hình thấp.
  • Doanh nghiệp & Nhà phân tích tài chính: Tiếp cận công cụ dự báo có độ chính xác cao, chi phí vận hành thấp, giúp tối ưu hóa dự báo dòng tiền, nguyên vật liệu và quản trị rủi ro biến động giá.
  • Nhà nghiên cứu khoa học: Khung đối chuẩn tin cậy giữa các phương pháp lai ghép closed-form với các mạng nơ-ron sâu (LSTM, GRU) trên dữ liệu thực tế.

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

1. Yêu cầu phần cứng và môi trường để triển khai mô hình là gì?

Hệ thống có thể vận hành mượt mà trên môi trường CPU tiêu chuẩn (Intel Core i3/i5 thế hệ 8 trở lên hoặc tương đương), RAM tối thiểu 4GB, không yêu cầu GPU rời. Về phần mềm, chỉ cần cài đặt môi trường Python 3.8+ cùng các thư viện phổ biến: numpy, pandas, statsmodels, scikit-learn và streamlit.

2. Khi nào nên chọn mô hình lai ghép song song thay vì tuần tự?

Mô hình song song phát huy hiệu quả tối đa khi cả hai mô hình thành phần (ARIMA và PC) đều có khả năng nắm bắt tốt các khía cạnh khác nhau của chuỗi dữ liệu gốc, giúp trọng số $\alpha$ dung hòa sai số của cả hai. Mô hình tuần tự (Additive/Multiplicative) thích hợp nhất khi chuỗi có thành phần xu hướng tuyến tính rất rõ rệt cần ARIMA bóc tách trước, để lại phần dư thuần túy phi tuyến cho PC xử lý.

3. Tại sao không sử dụng bậc đa thức cao hơn (bậc 4, bậc 5) để tăng độ chính xác?

Việc tăng bậc đa thức $k \ge 3$ làm tăng số chiều ma trận theo hàm mũ, dẫn đến hiện tượng đa cộng tuyến (multicollinearity) và làm ma trận $M^T M$ tiến gần đến trạng thái suy biến. Điều này gây ra sai số làm tròn số học lớn và hiện tượng overfitting nghiêm trọng, khiến sai số kiểm thử (test error) tăng vọt.

4. Chi phí bảo trì và cập nhật mô hình định kỳ như thế nào?

Chi phí bảo trì cực kỳ thấp. Do thuật toán Polynomial Classifier sử dụng công thức nghiệm giải tích dạng đóng (closed-form), quá trình tái huấn luyện (retraining) khi có dữ liệu mới chỉ mất dưới 1 giây, cho phép hệ thống cập nhật trọng số liên tục theo từng ngày giao dịch mà không làm gián đoạn dịch vụ.

5. Mô hình xử lý các điểm dị biệt (outliers) hoặc dữ liệu khuyết thiếu ra sao?

Trước khi đưa vào pipeline dự báo, module tiền xử lý sẽ áp dụng phương pháp nội suy tuyến tính (Linear Interpolation) cho dữ liệu khuyết thiếu và thuật toán $Z$-score / IQR để phát hiện và làm mịn các giá trị dị biệt bất thường, đảm bảo tính ổn định cho quá trình ước lượng sai phân và ma trận trọng số.

Kết luận

Đồ án tốt nghiệp "Dự báo dữ liệu chuỗi thời gian sử dụng mô hình lai ghép Polynomial Classifier và ARIMA" của nhóm tác giả Nguyễn Trị Quốc và Trương Thị Thu Sương (Chuyên ngành Kỹ thuật Dữ liệu, Trường Đại học Sư phạm Kỹ thuật TP.HCM) dưới sự hướng dẫn của TS. Nguyễn Thành Sơn đã giải quyết thành công bài toán cân bằng giữa độ chính xác dự báo và hiệu năng tính toán.

Thông qua việc kết hợp tính chặt chẽ trong phân tích chuỗi dừng tuyến tính của ARIMA với năng lực trích xuất quan hệ phi tuyến mạnh mẽ của Polynomial Classifier, nghiên cứu đã đề xuất thành công các kiến trúc lai ghép tuần tự và song song tối ưu. Kết quả thực nghiệm trên 4 bộ dữ liệu đa dạng (Delhi_Climate, Gold_Price, Dau_Tho, Monthly_Beer) chứng minh mô hình lai ghép giảm sai số RMSE từ 11.2% đến 38.7% so với ARIMA đơn lẻ, đồng thời vượt trội các mô hình Deep Learning (LSTM, GRU) về tốc độ huấn luyện gấp hơn 30 lần. Đây là giải pháp công nghệ mang tính ứng dụng cao, sẵn sàng phục vụ cho các bài toán phân tích kinh doanh, dự báo tài chính và quản trị thông minh trong thực tiễn.