Giới thiệu dự án

Thị trường tiền mã hóa (Cryptocurrency) trong giai đoạn 2020–2021 đã chứng kiến sự bùng nổ chưa từng có về vốn hóa và khối lượng giao dịch. Bitcoin (BTC) vượt mốc 60.000 USD và Ethereum (ETH) vượt ngưỡng 4.000 USD đã biến tài sản kỹ thuật số từ một thị trường ngách thành một phân lớp tài sản tài chính toàn cầu. Khác biệt với thị trường chứng khoán truyền thống có khung giờ giao dịch cố định và biên độ dao động được kiểm soát, thị trường crypto hoạt động liên tục 24/7 với tính biến động cực cao (high volatility), chịu ảnh hưởng mạnh bởi tâm lý đám đông, tính thanh khoản và các đợt biến động giá phi tuyến tính.

Dự báo giá và ra quyết định giao dịch tiền mã hóa là một bài toán chuỗi thời gian (Time Series Forecasting) phức tạp. Các phương pháp phân tích kỹ thuật truyền thống (như RSI, MACD, Bollinger Bands) thường có độ trễ lớn và phụ thuộc vào cảm tính chủ quan của nhà đầu tư. Trong khi đó, các mô hình thống kê tuyến tính thuần túy như ARIMA không thể nắm bắt được các thành phần phi tuyến và đột biến bất thường (irregular components) của thị trường. Ngược lại, các mạng nơ-ron học sâu (Deep Learning) độc lập như RNN/LSTM tuy giỏi trích xuất đặc trưng phi tuyến nhưng lại dễ rơi vào tình trạng quá khớp (overfitting) và thiếu khả năng diễn giải cấu trúc xu thế tuyến tính cơ sở. Hơn nữa, việc chỉ dự báo mức giá đơn thuần không đồng nghĩa với việc tối ưu hóa được lợi nhuận nếu thiếu một cơ chế khuyến nghị hành động mua/bán (Buy/Sell/Hold) mang tính chiến lược.

Khóa luận tốt nghiệp "Xây dựng hệ thống dự báo giá và khuyến nghị giao dịch mua bán tiền mã hóa" (Building a System Forecasting Rate and Recommending Transaction about Crypto Currency) do sinh viên Nguyễn Minh Nhựt thực hiện dưới sự hướng dẫn của PGS. TS. Nguyễn Đình Thuận tại Trường Đại học Công nghệ Thông tin – ĐHQG TP.HCM giải quyết bài toán này thông qua việc kết hợp các mô hình lai (Hybrid Models) và thuật toán học tăng cường (Reinforcement Learning).

graph TD
    A[Dữ liệu giá lịch sử BTC/ETH] --> B[Tiền xử lý & Kiểm định ADF]
    B --> C[Phân rã chuỗi thời gian: Tuyến tính & Phi tuyến]
    C --> D[Mô hình Tuyến tính: ARIMA]
    C --> E[Mô hình Phi tuyến: SVR / LSTM]
    D --> F[Mô hình lai Hybrid ARIMA-SVR / ARIMA-LSTM]
    E --> F
    F --> G[Giá trị dự báo Closing Price]
    G --> H[Mô hình Học tăng cường Q-Learning]
    H --> I[Khuyến nghị Giao dịch: Buy / Sell / Hold]
    I --> J[Hệ thống Web Client & RESTful API]

Mục tiêu đề tài

  1. Nghiên cứu lý thuyết chuỗi thời gian: Khảo sát tính dừng, phân tích các thành phần xu thế ($T$), mùa vụ ($S$), chu kỳ ($C$), và bất thường ($I$) trên tập dữ liệu giá đóng cửa (Closing Price) của Bitcoin và Ethereum.
  2. Xây dựng và đánh giá các mô hình dự báo đơn lẻ: Triển khai mô hình kinh tế lượng ARIMA(p,d,q), mô hình học máy hồi quy véc-tơ hỗ trợ (SVR), và mạng nơ-ron hồi quy có cổng nhớ dài-ngắn hạn (LSTM).
  3. Phát triển mô hình lai (Hybrid Models): Tích hợp ARIMA-SVR và ARIMA-LSTM nhằm kết hợp ưu thế trích xuất quan hệ tuyến tính của ARIMA và khả năng học phần dư phi tuyến của SVR/LSTM.
  4. Xây dựng hệ thống khuyến nghị giao dịch bằng Q-Learning: Thiết lập môi trường học tăng cường tự động sinh chiến lược Mua (Buy), Bán (Sell) hoặc Giữ (Hold) dựa trên ma trận $Q\text{-Table}$.
  5. Đóng gói và triển khai hệ thống thực tế: Phát triển kiến trúc web toàn diện gồm lõi tính toán Python, hệ thống RESTful API bằng Laravel, cơ sở dữ liệu MySQL, cơ chế lập lịch tự động Linux CRON, và giao diện người dùng tương tác Vue.js.

Phạm vi và giới hạn đề tài

  • Đối tượng dữ liệu: Giá đóng cửa theo ngày (Daily Closing Price) của 2 đồng tiền mã hóa có vốn hóa lớn nhất thị trường: Bitcoin (BTC/USD) và Ethereum (ETH/USD).
  • Khung thời gian dự báo: Dự báo điểm bước kế tiếp ($t+1$) theo chu kỳ ngày.
  • Giới hạn: Hệ thống tập trung vào dữ liệu chuỗi thời gian lịch sử của giá, chưa tích hợp dữ liệu phân tích cảm xúc mạng xã hội (Sentiment Analysis) hoặc dữ liệu sổ lệnh (Order Book Depth).

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

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

Phương pháp tiếp cận Ưu điểm Nhược điểm Độ chính xác dự báo (MAPE)
Phân tích kỹ thuật (RSI, MACD, MA) Trực quan, dễ sử dụng, tích hợp sẵn trên TradingView Độ trễ cao, tín hiệu giả nhiều khi thị trường biến động mạnh, không học được quy luật dữ liệu Không định lượng ($> 15%$)
Mô hình Thống kê (ARIMA đơn lẻ) Nắm bắt cấu trúc tuyến tính tốt, toán học rõ ràng, chi phí tính toán thấp Không xử lý được dữ liệu phi tuyến, nhạy cảm với biến động bất thường $4.5% - 8.2%$
Học sâu thuần túy (LSTM đơn lẻ) Tự động trích xuất đặc trưng phi tuyến, lưu giữ phụ thuộc dài hạn Cần dữ liệu lớn, dễ overfitting, chi phí huấn luyện cao $3.0% - 5.5%$
Mô hình Lai đề xuất (ARIMA-LSTM/SVR + Q-Learning) Khử nhiễu tuyến tính, bù đắp phần dư phi tuyến, tích hợp ra quyết định tự động Kiến trúc phức tạp, cần đồng bộ hóa pipeline đa ngôn ngữ $1.8% - 3.2%$

Yêu cầu hệ thống theo mô hình MoSCoW

  • Must Have (Bắt buộc có):
    • Pipeline thu thập dữ liệu lịch sử và tự động cập nhật giá BTC/ETH hàng ngày.
    • Kiểm định tính dừng Augmented Dickey-Fuller (ADF) và biến đổi sai phân bậc $d$.
    • Module dự báo giá với mô hình đơn lẻ (ARIMA, SVR, LSTM) và mô hình kết hợp (Hybrid).
    • Module khuyến nghị 3 hành động (Buy/Sell/Hold) sử dụng thuật toán Q-Learning.
    • RESTful API cung cấp dữ liệu chuỗi thời gian và kết quả dự báo cho Web Client.
  • Should Have (Nên có):
    • Hệ thống lập lịch tự động (CRON Task Scheduling) chạy ngầm trên máy chủ Linux.
    • Giao diện trực quan hóa dạng bảng và biểu đồ tương tác thời gian thực.
  • Could Have (Có thể có):
    • Khả năng xuất dữ liệu báo cáo ra định dạng CSV.
    • So sánh trực quan sai số giữa các mô hình trên cùng một khung nhìn giao diện.
  • Won't Have (Chưa thực hiện trong giai đoạn này):
    • Đặt lệnh giao dịch tự động thông qua API của các sàn giao dịch (Binance/Coinbase).
    • Dự báo tần suất cao (High-Frequency Trading theo khung phút/giây).

Thiết kế hệ thống và Kiến trúc phần mềm

Hệ thống được thiết kế theo mô hình kiến trúc phân tầng (Layered Architecture) tách biệt giữa tầng tính toán khoa học dữ liệu (Data Science Engine), tầng xử lý logic dịch vụ (API Backend), và tầng trình diễn (Frontend Client).

+-----------------------------------------------------------------------+
|                       PRESENTATION LAYER                              |
|   Vue.js 2.x Dashboard (Historical Charts, Prediction View, Q-Action) |
+-----------------------------------------------------------------------+
                                   | HTTP / JSON REST APIs
+-----------------------------------------------------------------------+
|                         APPLICATION API LAYER                         |
|   Laravel Framework 8.x (PHP 7.4)                                      |
|   - CryptoController (Data Ingestion, Historical Serving)             |
|   - ForecastController (Model Output Orchestration)                   |
|   - Task Scheduling Subsystem (Laravel Command Bus)                   |
+-----------------------------------------------------------------------+
          |                                            |
          | Exec Process / Shell                       | Eloquent ORM
+------------------------------------+   +------------------------------+
|       MACHINE LEARNING ENGINE      |   |       DATA STORAGE LAYER     |
|   Python 3.6 Runtime               |   |   MySQL Database Server      |
|   - Statsmodels (ARIMA)            |   |   - cryptos                  |
|   - Scikit-Learn (SVR Kernel)      |   |   - historical_prices        |
|   - Keras / TensorFlow (LSTM Core) |   |   - forecast_records         |
|   - Q-Learning Strategy Generator  |   |   - qlearning_recommendations|
+------------------------------------+   +------------------------------+
                                   ^
                                   | Linux Crontab Daemon (* * * * *)
+-----------------------------------------------------------------------+
|                    INFRASTRUCTURE & HOSTING LAYER                     |
|   Ubuntu Linux Cloud Server (Nginx + PHP-FPM + Python Virtualenv)     |
+-----------------------------------------------------------------------+

Technology Stack và phiên bản chi tiết

  • Machine Learning Core: Python 3.6, Scikit-Learn 0.24, Keras 2.4.3 / TensorFlow 2.3, Statsmodels 0.12, Pandas 1.1.5, NumPy 1.19.
  • Backend API Engine: PHP 7.4, Laravel Framework 8.x, Composer Dependency Manager.
  • Frontend Client: Vue.js 2.6, Axios, Chart.js / Highcharts, Bootstrap 4.
  • Database Engine: MySQL 5.7 / 8.0.
  • Deployment & OS: Ubuntu Server 20.04 LTS, Nginx 1.18, Linux Cron Daemon.

Thiết kế Cơ sở dữ liệu (Database Schema)

-- Bảng danh mục đồng tiền mã hóa
CREATE TABLE `cryptos` (
    `id` INT AUTO_INCREMENT PRIMARY KEY,
    `symbol` VARCHAR(10) NOT NULL UNIQUE, -- BTC, ETH
    `name` VARCHAR(50) NOT NULL,
    `created_at` TIMESTAMP DEFAULT CURRENT_TIMESTAMP
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

-- Bảng dữ liệu giá lịch sử
CREATE TABLE `historical_prices` (
    `id` BIGINT AUTO_INCREMENT PRIMARY KEY,
    `crypto_id` INT NOT NULL,
    `record_date` DATE NOT NULL,
    `open_price` DECIMAL(18, 4) NOT NULL,
    `high_price` DECIMAL(18, 4) NOT NULL,
    `low_price` DECIMAL(18, 4) NOT NULL,
    `close_price` DECIMAL(18, 4) NOT NULL,
    `volume` DECIMAL(24, 4) NOT NULL,
    FOREIGN KEY (`crypto_id`) REFERENCES `cryptos`(`id`) ON DELETE CASCADE,
    UNIQUE KEY `crypto_date_unique` (`crypto_id`, `record_date`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

-- Bảng lưu trữ kết quả dự báo từ các mô hình
CREATE TABLE `forecast_records` (
    `id` BIGINT AUTO_INCREMENT PRIMARY KEY,
    `crypto_id` INT NOT NULL,
    `forecast_date` DATE NOT NULL,
    `model_type` ENUM('ARIMA', 'SVR', 'LSTM', 'HYBRID_ARIMA_SVR', 'HYBRID_ARIMA_LSTM') NOT NULL,
    `predicted_price` DECIMAL(18, 4) NOT NULL,
    `actual_price` DECIMAL(18, 4) NULL,
    `error_percentage` DECIMAL(8, 4) NULL,
    `created_at` TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    FOREIGN KEY (`crypto_id`) REFERENCES `cryptos`(`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

-- Bảng khuyến nghị giao dịch từ Q-Learning
CREATE TABLE `qlearning_recommendations` (
    `id` BIGINT AUTO_INCREMENT PRIMARY KEY,
    `crypto_id` INT NOT NULL,
    `decision_date` DATE NOT NULL,
    `state_index` INT NOT NULL,
    `action` ENUM('BUY', 'SELL', 'HOLD') NOT NULL,
    `q_value` DECIMAL(12, 6) NOT NULL,
    `created_at` TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    FOREIGN KEY (`crypto_id`) REFERENCES `cryptos`(`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

Thiết kế RESTful API Endpoints

HTTP Method Endpoint URI Chức năng Tham số chính
GET /api/v1/crypto/list Lấy danh sách các đồng tiền hỗ trợ Không có
GET /api/v1/crypto/{symbol}/history Lấy lịch sử giá đóng cửa start_date, end_date, limit
GET /api/v1/crypto/{symbol}/forecast Lấy kết quả dự báo theo mô hình model_type, date
GET /api/v1/crypto/{symbol}/recommendation Lấy trạng thái khuyến nghị Buy/Sell/Hold date
POST /api/v1/system/cron/sync-data Kích hoạt tác vụ cập nhật dữ liệu từ nguồn api_token (Xác thực nội bộ)
POST /api/v1/system/cron/execute-models Kích hoạt script Python chạy dự báo api_token, symbol

Implementation và kết quả

Quy trình phát triển 4 giai đoạn (4-Phase Pipeline)

  1. Phase 1 – Huấn luyện mô hình dự báo và xây dựng cơ chế khuyến nghị:
    • Thu thập dữ liệu lịch sử giá đóng cửa của BTC và ETH giai đoạn 2019–2021.
    • Triển khai thuật toán Box-Jenkins để tìm bộ tham số tối ưu $(p, d, q)$ cho mô hình ARIMA thông qua tiêu chí AIC (Akaike Information Criterion).
    • Xây dựng mô hình Support Vector Regression (SVR) với hàm nhân RBF (Radial Basis Function).
    • Thiết kế mạng LSTM sâu với cấu trúc cổng Forget, Input, Output và trạng thái tế bào (Cell State).
    • Xây dựng thuật toán học tăng cường Q-Learning ánh xạ các trạng thái biến động giá thành ma trận giá trị $Q(s, a)$.
  2. Phase 2 – Xây dựng hệ thống Backend API (Laravel):
    • Viết các tác vụ bóc tách dữ liệu (Data Scraper/Crawler) lấy dữ liệu giá thị trường hàng ngày.
    • Xây dựng Controllers, Models, Middleware và API Routes phục vụ dữ liệu chuỗi thời gian.
  3. Phase 3 – Triển khai trên máy chủ Linux Cloud & Thiết lập định thời:
    • Cài đặt môi trường runtime trên Ubuntu Linux.
    • Thiết lập Linux Crontab kết nối với Task Scheduler của Laravel để tự động hóa quy trình lấy dữ liệu và chạy suy luận mô hình hàng ngày.
  4. Phase 4 – Phát triển giao diện người dùng tương tác (Vue.js):
    • Xây dựng Single Page Application (SPA) hiển thị biểu đồ lịch sử, đồ thị dự báo so sánh thực tế và bảng tín hiệu khuyến nghị giao dịch.

Chi tiết các thuật toán then chốt và cơ sở toán học

1. Mô hình ARIMA và Phương pháp Box-Jenkins

Mô hình ARIMA(p,d,q) tổng quát kết hợp giữa tự hồi quy $\text{AR}(p)$, sai phân bậc $d$ để đảm bảo tính dừng, và trung bình trượt $\text{MA}(q)$:

$$\Phi(B)(1 - B)^d y_t = \Theta(B)\epsilon_t$$

Trong đó $B$ là toán tử lùi thời gian ($B^k y_t = y_{t-k}$), $\Phi(B) = 1 - \sum_{i=1}^p \phi_i B^i$, $\Theta(B) = 1 + \sum_{j=1}^q \theta_j B^j$, và $\epsilon_t \sim WN(0, \sigma^2)$ là nhiễu trắng.

Kiểm định tính dừng Augmented Dickey-Fuller (ADF) được thực hiện với phương trình:

$$\Delta y_t = \alpha + \beta t + \gamma y_{t-1} + \sum_{i=1}^k \delta_i \Delta y_{t-i} + \epsilon_t$$

Nếu giá trị kiểm định $t\text{-statistic} > \text{Critical Value}$ ở mức ý nghĩa $5%$, chuỗi có nghiệm đơn vị (không dừng) và phải tiếp tục lấy sai phân bậc $d = d + 1$.

2. Mô hình Hồi quy Véc-tơ Hỗ trợ (Support Vector Regression - SVR)

SVR ánh xạ không gian đầu vào phi tuyến sang không gian đặc trưng nhiều chiều thông qua hàm nhân Kernel $K(x_i, x) = \exp(-\gamma ||x_i - x||^2)$, giải bài toán tối ưu hóa lồi có ràng buộc biên $\epsilon$-insensitive:

$$\min_{w, b, \xi, \xi^} \frac{1}{2} ||w||^2 + C \sum_{i=1}^N (\xi_i + \xi_i^)$$

$$\text{thỏa mãn: } \begin{cases} y_i - (w^T \phi(x_i) + b) \le \epsilon + \xi_i \ (w^T \phi(x_i) + b) - y_i \le \epsilon + \xi_i^* \ \xi_i, \xi_i^* \ge 0 \end{cases}$$

3. Mô hình Bộ nhớ Dài-Ngắn hạn (LSTM Core)

Khối LSTM block giải quyết triệt để vấn đề suy giảm đạo hàm (Vanishing Gradient) trong chuỗi thời gian dài thông qua 3 cổng điều khiển:

$$\text{Forget Gate: } f_t = \sigma(W_f \cdot [h_{t-1}, x_t] + b_f)$$

$$\text{Input Gate: } i_t = \sigma(W_i \cdot [h_{t-1}, x_t] + b_i)$$

$$\text{Candidate Cell: } \tilde{C}t = \tanh(W_c \cdot [h{t-1}, x_t] + b_c)$$

$$\text{Updated Cell State: } C_t = f_t \odot C_{t-1} + i_t \odot \tilde{C}_t$$

$$\text{Output Gate: } o_t = \sigma(W_o \cdot [h_{t-1}, x_t] + b_o)$$

$$\text{Hidden State: } h_t = o_t \odot \tanh(C_t)$$

4. Mô hình Lai Phân rã Phần dư (Hybrid ARIMA-LSTM Decomposition)

Một chuỗi thời gian tài chính $y_t$ được phân rã thành hai thành phần tuyến tính $L_t$ và phi tuyến $N_t$:

$$y_t = L_t + N_t$$

  • Bước 1: Sử dụng ARIMA để khớp và dự báo thành phần tuyến tính $\hat{L}_t$.
  • Bước 2: Tính toán chuỗi phần dư (Residual series): $e_t = y_t - \hat{L}_t$.
  • Bước 3: Sử dụng mạng LSTM (hoặc SVR) để huấn luyện trên chuỗi phần dư $e_t$, dự báo thành phần phi tuyến $\hat{N}t = f(e{t-1}, e_{t-2}, \dots, e_{t-k})$.
  • Bước 4: Tổng hợp kết quả dự báo cuối cùng: $\hat{y}_t = \hat{L}_t + \hat{N}_t$.

5. Thuật toán Khuyến nghị Q-Learning

Mô hình khuyến nghị sử dụng học tăng cường không mô hình (Model-free Reinforcement Learning) để tối ưu hóa chính sách giao dịch. Phương trình cập nhật Bellman cho giá trị $Q(s_t, a_t)$:

$$Q(s_t, a_t) \leftarrow Q(s_t, a_t) + \alpha \left[ R_{t+1} + \gamma \max_{a} Q(s_{t+1}, a) - Q(s_t, a_t) \right]$$

Trong đó:

  • Tập trạng thái ($S$): Được định nghĩa bằng mức độ biến động giá tương đối giữa giá dự báo $\hat{y}_{t+1}$ và giá hiện tại $y_t$.
  • Tập hành động ($A$): $a \in {\text{Buy } (+1), \text{Sell } (-1), \text{Hold } (0)}$.
  • Hàm phần thưởng ($R$): Lợi nhuận thực tế thu được sau khi thực hiện hành động tại thời điểm $t+1$.
  • $\alpha \in (0, 1]$ là tốc độ học (Learning Rate), $\gamma \in [0, 1)$ là hệ số chiết khấu tương lai (Discount Factor).

Trích đoạn mã nguồn thực thi chính

# hybrid_forecast_engine.py
import numpy as np
import pandas as pd
from statsmodels.tsa.arima.model import ARIMA
from sklearn.preprocessing import MinMaxScaler
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dense, Dropout

def train_hybrid_arima_lstm(train_series, test_len=30, arima_order=(5, 1, 0), look_back=5):
    """
    Huấn luyện mô hình lai ARIMA-LSTM trên chuỗi giá đóng cửa.
    """
    # 1. Khớp mô hình ARIMA trên chuỗi gốc
    arima_model = ARIMA(train_series, order=arima_order).fit()
    arima_fitted = arima_model.fittedvalues
    residuals = train_series - arima_fitted
    
    # 2. Chuẩn hóa phần dư phi tuyến cho LSTM
    scaler = MinMaxScaler(feature_range=(-1, 1))
    scaled_res = scaler.fit_transform(residuals.values.reshape(-1, 1))
    
    # Tạo dataset chuỗi thời gian look-back
    X, y = [], []
    for i in range(len(scaled_res) - look_back):
        X.append(scaled_res[i:(i + look_back), 0])
        y.append(scaled_res[i + look_back, 0])
    X, y = np.array(X), np.array(y)
    X = np.reshape(X, (X.shape[0], X.shape[1], 1))
    
    # 3. Xây dựng mạng LSTM học phần dư
    lstm_model = Sequential([
        LSTM(64, activation='tanh', return_sequences=True, input_shape=(look_back, 1)),
        Dropout(0.2),
        LSTM(32, activation='tanh'),
        Dropout(0.2),
        Dense(1)
    ])
    lstm_model.compile(optimizer='adam', loss='mean_squared_error')
    lstm_model.fit(X, y, epochs=50, batch_size=16, verbose=0)
    
    return arima_model, lstm_model, scaler

// app/Console/Kernel.php - Cấu hình CRON tự động hóa trong Laravel
namespace App\Console;

use Illuminate\Console\Scheduling\Schedule;
use Illuminate\Foundation\Console\Kernel as ConsoleKernel;

class Kernel extends ConsoleKernel
{
    protected function schedule(Schedule $schedule)
    {
        // 1. Tự động lấy dữ liệu giá đóng cửa mới nhất lúc 00:05 mỗi ngày
        $schedule->command('crypto:sync-daily-prices')
                 ->dailyAt('00:05')
                 ->appendOutputTo(storage_path('logs/cron_sync.log'));

        // 2. Chạy pipeline Python Machine Learning dự báo giá lúc 00:15
        $schedule->command('crypto:run-prediction-models')
                 ->dailyAt('00:15')
                 ->appendOutputTo(storage_path('logs/cron_forecast.log'));

        // 3. Chạy thuật toán Q-Learning sinh khuyến nghị giao dịch lúc 00:25
        $schedule->command('crypto:generate-qlearning-action')
                 ->dailyAt('00:25')
                 ->appendOutputTo(storage_path('logs/cron_recommendation.log'));
    }

    protected function commands()
    {
        $this->load(__DIR__.'/Commands');
    }
}

# Cấu hình Crontab trên máy chủ Linux Ubuntu Server (crontab -e)
* * * * * cd /var/www/crypto-forecast-system && php artisan schedule:run >> /dev/null 2>&1

Đánh giá mô hình và Kết quả thực nghiệm

Hiệu năng của các mô hình dự báo được đánh giá định lượng thông qua hai chỉ số chuẩn:

$$\text{Root Mean Square Error (RMSE)} = \sqrt{\frac{1}{N} \sum_{t=1}^N (y_t - \hat{y}_t)^2}$$

$$\text{Mean Absolute Percentage Error (MAPE)} = \frac{100%}{N} \sum_{t=1}^N \left| \frac{y_t - \hat{y}_t}{y_t} \right|$$

Bảng so sánh sai số giữa các mô hình trên tập kiểm thử (Test Dataset)

Đồng tiền Mô hình dự báo RMSE (USD) MAPE (%) Đánh giá hiệu năng
Bitcoin (BTC) ARIMA(5,1,0) 1,428.50 4.82% Baseline thống kê
SVR (RBF Kernel) 1,180.20 3.91% Học máy hồi quy
LSTM (Deep Recurrent) 985.40 3.12% Mạng nơ-ron học sâu
Hybrid ARIMA-SVR 820.60 2.54% Kết hợp thống kê + SVR
Hybrid ARIMA-LSTM 645.30 1.89% Tối ưu nhất (Giảm 60.7% MAPE so với ARIMA)
Ethereum (ETH) ARIMA(3,1,2) 142.10 5.34% Baseline thống kê
SVR (RBF Kernel) 115.80 4.10% Học máy hồi quy
LSTM (Deep Recurrent) 92.40 3.25% Mạng nơ-ron học sâu
Hybrid ARIMA-SVR 78.50 2.68% Kết hợp thống kê + SVR
Hybrid ARIMA-LSTM 58.20 1.96% Tối ưu nhất (Giảm 63.3% MAPE so với ARIMA)

Đánh giá chiến lược khuyến nghị Q-Learning

Trong thử nghiệm mô phỏng giao dịch 90 ngày (Backtesting) trên cặp BTC/USD:

  • Tỷ lệ dự đoán đúng hướng (Directional Accuracy): Đạt $76.4%$.
  • Tổng lợi nhuận ròng (Net Profit ROI): Mô hình Q-Learning đạt mức lợi nhuận $+28.6%$, vượt trội so với chiến lược thụ động Buy & Hold ($+11.2%$) trong cùng giai đoạn thị trường đi ngang có điều chỉnh mạnh.
  • Tối đa sụt giảm tài khoản (Max Drawdown): Được kiểm soát ở mức $8.4%$ nhờ hành động "Hold/Sell" kịp thời khi mô hình dự báo chu kỳ điều chỉnh.

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

  1. Khắc phục triệt để điểm nghẽn của mô hình đơn lẻ bằng kiến trúc Hybrid: Thay vì sử dụng một mô hình duy nhất chịu quá tải cả đặc trưng tuyến tính lẫn phi tuyến, hệ thống phân rã bài toán thành 2 giai đoạn: ARIMA xử lý thành phần xu thế chuỗi dừng, và LSTM/SVR xử lý phần dư sai số. Cách tiếp cận này giúp giảm chỉ số MAPE từ $4.82%$ xuống còn $1.89%$ trên dữ liệu Bitcoin.
  2. Khép kín vòng lặp từ Dự báo đến Ra quyết định (Decision-making Integration): Đa số các nghiên cứu học thuật chỉ dừng lại ở bước đưa ra con số giá trị dự báo $\hat{y}_{t+1}$. Đồ án đã tích hợp thành công mô hình học tăng cường Q-Learning, chuyển đổi sai số dự báo và xu hướng biến động giá thành ma trận quyết định trực quan (Buy/Sell/Hold) hỗ trợ trực tiếp cho người dùng.
  3. Tự động hóa hoàn chỉnh trên nền tảng hạ tầng Cloud Linux: Thiết kế thành công quy trình khép kín không cần sự can thiệp thủ công: Tự động trích xuất dữ liệu mới $\rightarrow$ Chạy suy luận mô hình $\rightarrow$ Cập nhật $Q\text{-Table}$ $\rightarrow$ Đồng bộ CSDL $\rightarrow$ Phân phối dữ liệu qua RESTful API đến giao diện Vue.js.

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

Kịch bản sử dụng thực tế (Use Case Scenarios)

  • Nhà đầu tư cá nhân (Retail Traders): Truy cập trang tổng quan web để theo dõi đồ thị so sánh giữa giá thực tế và giá dự báo ngày kế tiếp, đồng thời tham khảo tín hiệu khuyến nghị Buy/Sell/Hold để loại bỏ yếu tố cảm xúc (FOMO/Panic Selling).
  • Hệ thống giao dịch tự động (Algorithmic Trading Bot): Tích hợp trực tiếp các REST API endpoint (/api/v1/crypto/btc/recommendation) để làm bộ lọc tín hiệu xác nhận trước khi thực thi lệnh tự động qua sàn giao dịch.

Hướng dẫn triển khai hệ thống (Deployment Guide)

Yêu cầu hệ thống tối thiểu (System Requirements)

  • Server OS: Ubuntu 20.04 LTS x86_64.
  • Hardware: CPU 2 Cores, RAM 4GB (khuyến nghị 8GB để huấn luyện lại LSTM), 20GB SSD Storage.
  • Runtimes: PHP $\ge 7.4$, Python $\ge 3.6$, MySQL $\ge 5.7$, Nginx $\ge 1.18$.

Các bước cài đặt

# 1. Clone source code và cài đặt phụ thuộc PHP/Laravel
git clone https://github.com/minhnhut/crypto-forecast-system.git /var/www/crypto-forecast
cd /var/www/crypto-forecast
composer install --no-dev --optimize-autoloader
cp .env.example .env && php artisan key:generate

# 2. Cấu hình CSDL và chạy Migration
php artisan migrate --seed

# 3. Thiết lập môi trường Python Machine Learning
python3 -m venv venv
source venv/bin/activate
pip install -r requirements.txt # statsmodels, scikit-learn, tensorflow, pandas

# 4. Cấu hình Nginx Virtual Host và quyền thư mục
chown -R www-data:www-data /var/www/crypto-forecast/storage /var/www/crypto-forecast/bootstrap/cache
chmod -R 775 /var/www/crypto-forecast/storage

# 5. Kích hoạt CRON Daemon
crontab -e
# Thêm dòng: * * * * * cd /var/www/crypto-forecast && php artisan schedule:run >> /dev/null 2>&1

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

Hạn chế kỹ thuật

  • Độ trễ theo ngày: Hệ thống hiện tại chỉ mới dự báo theo chu kỳ bước nhảy 1 ngày (Daily Closing Price), chưa hỗ trợ khung thời gian ngắn hơn (1 giờ, 4 giờ) cho các chiến lược giao dịch trong ngày (Intraday Trading).
  • Thiếu dữ liệu đa phương thức: Mô hình chưa tích hợp phân tích tâm lý thị trường từ mạng xã hội (Twitter Sentiment / Reddit Crypto Currency) và các chỉ số On-chain (ví cá voi, khối lượng nạp/rút sàn).
  • Biến cố Thiên nga đen (Black Swan Events): Khi thị trường xuất hiện các cú sốc chính sách hoặc sự cố bảo mật sàn giao dịch lớn, mô hình thuần chuỗi thời gian sẽ gặp sai số đột biến trong 1-2 phiên đầu tiên trước khi kịp thích ứng.

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

  • Tích hợp mô hình ngôn ngữ lớn (LLM) hoặc FinBERT để thực hiện Sentiment Analysis thời gian thực kết hợp cùng chuỗi thời gian.
  • Nâng cấp mô hình chuỗi thời gian từ LSTM lên kiến trúc Transformer / Informer / PatchTST nhằm xử lý tốt hơn mối quan hệ phụ thuộc siêu dài hạn.
  • Xây dựng module Smart Contract trên Ethereum để thực thi giao dịch phi tập trung (DeFi automated execution) dựa trên tín hiệu của Q-Learning.

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

  • Sinh viên & Người học ngành Hệ thống thông tin / Khoa học dữ liệu: Cung cấp tài liệu tham khảo hoàn chỉnh về cách kết hợp giữa lý thuyết kinh tế lượng cổ điển (ARIMA), học máy (SVR), học sâu (LSTM) và học tăng cường (Q-Learning) trong một ứng dụng thực tiễn.
  • Kỹ sư phần mềm & Lập trình viên: Cung cấp mẫu kiến trúc chuẩn (Architectural Pattern) trong việc kết nối module tính toán chuyên sâu Python với hệ thống Web Enterprise hiện đại bằng Laravel và Vue.js thông qua cơ chế định thời Linux CRON.
  • Nhà đầu tư & Tổ chức tài chính: Cung cấp một công cụ hỗ trợ ra quyết định độc lập, khách quan, dựa trên dữ liệu định lượng với sai số MAPE dưới $2%$.
  • Cộng đồng nghiên cứu AI/Fintech: Đóng góp cơ sở thực nghiệm rõ ràng về hiệu quả vượt trội của các mô hình phân rã phần dư (Hybrid Decomposition) so với các mạng nơ-ron đơn lẻ.

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 hệ thống là gì?

Hệ thống yêu cầu máy chủ chạy hệ điều hành Linux (khuyến nghị Ubuntu 20.04 LTS), tối thiểu 2 vCPU, 4GB RAM, cài đặt PHP 7.4+, MySQL 5.7+, Python 3.6+ cùng các thư viện statsmodels, scikit-learn, tensorflow/keras.

2. Tại sao mô hình kết hợp ARIMA-LSTM lại vượt trội hơn mô hình LSTM độc lập?

Mô hình LSTM độc lập khi phải tự học cả thành phần tuyến tính ổn định lẫn các dao động phi tuyến phức tạp rất dễ rơi vào tình trạng quá khớp (overfitting) hoặc khó hội tụ. Kiến trúc Hybrid sử dụng ARIMA để khử sạch các quy luật tuyến tính và cấu trúc xu thế cơ sở, giúp mạng LSTM chỉ cần tập trung toàn bộ dung lượng tham số để học chuỗi phần dư phi tuyến ($e_t$), từ đó tối ưu hóa độ chính xác tổng thể.

3. Hệ thống xử lý thế nào khi dữ liệu chuỗi thời gian không có tính dừng?

Hệ thống sử dụng kiểm định Augmented Dickey-Fuller (ADF) để kiểm tra p-value. Nếu chuỗi không dừng, thuật toán sẽ tự động thực hiện phép biến đổi sai phân liên tiếp bậc 1 hoặc bậc 2 ($d=1, d=2$) hoặc lấy logarit tự nhiên để đưa dữ liệu về trạng thái dừng hoàn toàn trước khi đưa vào mô hình ARIMA.

4. Thuật toán Q-Learning xác định hành động Buy/Sell/Hold dựa trên cơ chế nào?

Q-Learning định nghĩa các trạng thái thị trường dựa trên biên độ chênh lệch giữa giá đóng cửa hiện tại và giá dự báo ngày kế tiếp. Thông qua hàm phần thưởng (Reward Function) phản ánh tỷ suất sinh lời thực tế và phương trình cập nhật Bellman, thuật toán liên tục hiệu chỉnh bảng $Q\text{-Table}$ để chọn hành động có giá trị kỳ vọng cao nhất tại mỗi trạng thái.

5. Chi phí vận hành và tiềm năng mở rộng cho nhiều đồng tiền khác (Altcoins) ra sao?

Hệ thống có thể mở rộng dễ dàng cho hàng trăm đồng coin khác bằng cách thêm mã định danh vào bảng cryptos trong cơ sở dữ liệu. Do mô hình dự báo chạy theo tác vụ định thời hàng ngày (Batch Processing qua CRON) chứ không chạy liên tục từng giây, chi phí máy chủ Cloud chỉ tốn khoảng $10 - $20 USD/tháng trên các nền tảng như DigitalOcean, AWS EC2 hoặc Linode.

Kết luận

Đồ án tốt nghiệp "Xây dựng hệ thống dự báo giá và khuyến nghị giao dịch mua bán tiền mã hóa" của sinh viên Nguyễn Minh Nhựt đã giải quyết thành công bài toán dự báo tài chính phức tạp bằng cách kết hợp khoa học giữa kinh tế lượng truyền thống, học máy hiện đại và học tăng cường. Việc phát triển thành công mô hình lai Hybrid ARIMA-LSTM giúp kiểm soát sai số MAPE ở mức ấn tượng $1.89%$ đối với Bitcoin và $1.96%$ đối với Ethereum, vượt trội hoàn toàn so với các mô hình đơn lẻ.

Không chỉ dừng lại ở mặt nghiên cứu lý thuyết, đề tài đã hiện thực hóa giải pháp thành một sản phẩm công nghệ hoàn chỉnh với kiến trúc phân tầng chuyên nghiệp: kết hợp sức mạnh xử lý dữ liệu của Python, tính ổn định của Laravel Backend, tính tự động của Linux CRON, và trải nghiệm tương tác mượt mà của Vue.js Dashboard. Đây là nền tảng vững chắc có tính ứng dụng thực tế cao, mở ra tiềm năng lớn cho việc phát triển các hệ thống cố vấn tài chính tự động (Robo-Advisor) và giao dịch thuật toán thế hệ mới trong kỷ nguyên kinh tế số.