Giới thiệu dự án

Sự bùng nổ của đô thị hóa và gia tăng mật độ phương tiện cơ giới tại các siêu đô thị đặt ra thách thức nghiêm trọng cho hạ tầng quản lý giao thông. Theo thống kê từ các tổ chức vận tải quốc tế, ùn tắc giao thông gây thiệt hại hàng trăm tỷ USD mỗi năm về năng suất lao động, nhiên liệu và ô nhiễm môi trường. Việc chuyển đổi từ mô hình điều phối giao thông phản ứng thụ động (reactive) sang mô hình điều phối dự báo chủ động (proactive) thông qua Hệ thống Giao thông Thông minh (Intelligent Transportation System - ITS) đã trở thành giải pháp cấp thiết.

+-----------------------------------------------------------------------------------+
|                            NYC OpenData Traffic Stream                            |
|                     (50M+ Data Points, Sensors across NYC)                        |
+------------------------------------------+----------------------------------------+
                                           |
                                           v
+-----------------------------------------------------------------------------------+
|                Data Collection & Preprocessing (Apache Spark 3.1.2)               |
|      [Link_ID Resampling 5-min] ---> [Outlier Cleaning] ---> [Linear Interpolation] |
+------------------------------------------+----------------------------------------+
                                           |
                                           v
+-----------------------------------------------------------------------------------+
|               Distributed Training & Inference Engine (BigDL 2.0 / Chronos)       |
|    +----------------------+----------------------+---------------------------+    |
|    | Baseline: ARIMA/Prop | Deep Learning: LSTM  | SOTA: Dilated Causal TCN  |    |
|    +----------------------+----------------------+---------------------------+    |
|    |      Parameter Server Parallelism (Parameter Averaging / Gradient Update)|    |
+------------------------------------------+----------------------------------------+
                                           |
                                           v
+-----------------------------------------------------------------------------------+
|                   Real-time Traffic Flow Heatmap Dashboard                        |
|                  (Sub-second Latency, Multi-step Forecast Horizon)                |
+-----------------------------------------------------------------------------------+

Vấn đề thực tiễn (Problem Statement)

Các hệ thống cảm biến giao thông hiện đại liên tục thu thập dữ liệu với tần suất cao (30 giây - 1 phút/lần). Dữ liệu này mang đầy đủ 5 đặc trưng của Dữ liệu lớn (Big Data): Khối lượng (Volume), Tốc độ (Velocity), Tính đa dạng (Variety), Tính xác thực (Veracity) và Giá trị (Value). Các rào cản kỹ thuật cốt lõi bao gồm:

  • Dữ liệu phân tán và bất đồng bộ: Tín hiệu từ hàng chục nghìn cảm biến gặp tình trạng trễ mạng, mất gói, sinh ra dữ liệu khuyết thiếu (missing values) và dị biệt (outliers).
  • Hạn chế của mô hình truyền thống: Các phương pháp chuỗi thời gian cổ điển như ARIMA hay Vector Autoregression (VAR) chỉ xử lý tuyến tính, giả định chuỗi dừng, không mô hình hóa được mối tương quan phi tuyến tính và phụ thuộc thời gian dài (long-term temporal dependencies).
  • Điểm nghẽn tính toán thời gian thực: Các mô hình mạng nơ-ron hồi quy tuần tự (RNN/LSTM) gặp khó khăn trong việc mở rộng quy mô huấn luyện trên tập dữ liệu hàng chục triệu bản ghi nếu không có kiến trúc phân tán.

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

  1. Xây dựng quy trình xử lý luồng dữ liệu giao thông quy mô lớn theo thời gian thực (Real-time Stream Ingestion & Processing Pipeline) trên nền tảng Apache Spark.
  2. Thiết kế và tối ưu hóa các mô hình học sâu chuỗi thời gian, tập trung vào Mạng tích chập thời gian (Temporal Convolutional Network - TCN) và Mạng bộ nhớ ngắn-dài (Long Short-Term Memory - LSTM).
  3. Triển khai kiến trúc huấn luyện phân tán (Distributed Deep Learning) bằng cách tích hợp BigDL 2.0 (Intel Analytics Zoo) trên cụm phân tán Spark, song song hóa dữ liệu (Data Parallelism).
  4. Xây dựng giao diện trực quan hóa bản đồ nhiệt (Traffic Flow Heatmap) cập nhật theo thời gian thực phục vụ hỗ trợ ra quyết định.

Phương pháp tiếp cận và kết quả kỳ vọng

Dự án khai thác bộ dữ liệu mở NYC Real Time Traffic Speed Data Feed từ Sở Giao thông Vận tải Thành phố New York (NYC DOT) với hơn 50 triệu điểm dữ liệu. Hệ thống chuyển đổi bài toán dự báo chuỗi thời gian thống kê sang dạng bài toán học có giám sát đa bước (Multi-step Horizon Supervised Regression).

Kỳ vọng hệ thống đạt độ trễ xử lý luồng dưới 1 giây trên mỗi batch 5 phút, cải thiện sai số dự báo vận tốc giao thông (đo lường bằng MAE, RMSE, MAPE) vượt trội so với các mô hình Baseline (ARIMA, Facebook Prophet), đồng thời rút ngắn thời gian huấn luyện mô hình thông qua tính toán phân tán.

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

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

Phương pháp / Mô hình Bản chất thuật toán Ưu điểm Nhược điểm
ARIMA ($p, d, q$) Thống kê truyền thống kết hợp Tự hồi quy & Trung bình trượt Diễn giải toán học rõ ràng, hiệu quả với chuỗi dừng ngắn hạn Bắt buộc lấy sai phân chuỗi dừng; không học được quan hệ phi tuyến phức tạp; tốn chi phí huấn luyện lại khi thay đổi mốc dự báo
Facebook Prophet Mô hình cộng tính phi tuyến (Additive Decomposition) Xử lý tốt tính thời vụ (seasonality), xu hướng (trend) và ngày lễ Khả năng nắm bắt biến động cục bộ tần suất cao kém; khó tối ưu song song hóa trên quy mô siêu lớn
LSTM Networks Mạng nơ-ron hồi quy với cấu trúc cổng (Forget/Input/Output Gates) Khắc phục hiện tượng triệt tiêu đạo hàm (vanishing gradient) của RNN, học được phụ thuộc xa Tính toán tuần tự (sequential) không thể song song hóa qua các timestep; chi phí bộ nhớ lớn
TCN (Đề xuất) Tích chập 1D nhân quả giãn nở (Dilated Causal Conv) kết hợp Residual Song song hóa hoàn toàn quá trình tính toán chuỗi; trường tiếp nhận cực lớn; kiểm soát độ dốc ổn định Cần tính toán cấu hình kích thước kernel ($k$) và hệ số giãn nở ($d$) chính xác để tránh lỗ hổng tiếp nhận

Phân tích yêu cầu hệ thống theo mô hình MoSCoW

  • Must Have (Bắt buộc):
    • Khả năng thu thập luồng dữ liệu giao thông qua REST API/Streaming API của NYC OpenData.
    • Module tiền xử lý phân tán: Khử trùng lặp, lọc ngoại lai, nội suy tuyến tính lấp đầy dữ liệu trống và chuẩn hóa Resampling chu kỳ 5 phút.
    • Mô hình TCN phân tán dự báo tốc độ giao thông đa bước thời gian (5 phút, 15 phút, 30 phút, 60 phút).
  • Should Have (Nên có):
    • Tự động dò tìm siêu tham số (Hyperparameter Tuning) phân tán qua module BigDL Chronos / RayOnSpark.
    • Cơ chế đồng bộ trọng số tham số Parameter Averaging trên cụm máy chủ phân tán.
  • Could Have (Có thể có):
    • Bảng điều khiển trực quan hóa bản đồ nhiệt (Traffic Heatmap) tích hợp cảnh báo tắc nghẽn.
  • Won't Have (Chưa thực hiện):
    • Dự báo đa phương thức tích hợp hình ảnh camera giao thông hoặc điều khiển trực tiếp hệ thống đèn tín hiệu thông minh.

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

Kiến trúc giải pháp được thiết kế thành 3 phân lớp module liên hoàn:

[ NYC OpenData Traffic API ]

Technology Stack chi tiết

  • Nền tảng xử lý dữ liệu lớn: Apache Spark 3.1.2 (Spark Core, Spark Streaming, Spark SQL).
  • Khung học sâu phân tán: BigDL 2.0 (Intel Analytics Zoo), tích hợp RayOnSpark và BigDL-Chronos toolkit.
  • Thư viện Machine Learning & Deep Learning: PyTorch 1.9.0 / TensorFlow 2.6.0, Prophet 1.0, Statsmodels 0.12 (cho mô hình ARIMA).
  • Ngôn ngữ lập trình: Python 3.8, Scala 2.12.
  • Môi trường phân tán & Điều phối: Apache Hadoop YARN / Spark Standalone Cluster Manager.

Implementation và kết quả

Chi tiết kiến trúc mô hình và thuật toán cốt lõi

1. Mô hình Mạng tích chập thời gian (Temporal Convolutional Network - TCN)

Mô hình TCN sử dụng hai kỹ thuật nền tảng:

  • Tích chập nhân quả (Causal Convolution): Đảm bảo tại thời điểm $t$, đầu ra chỉ phụ thuộc vào các phần tử tại thời điểm $t, t-1, \dots, t-k$ từ quá khứ, loại trừ hoàn toàn việc rò rỉ thông tin tương lai (data leakage). Zero-padding được bổ sung với độ dài $p = (k - 1) \cdot d$.
  • Tích chập giãn nở (Dilated Convolution): Tăng trường tiếp nhận (Receptive Field) theo cấp số nhân mà không làm bùng nổ số lượng tham số: $$\text{Receptive Field: } w = 1 + \sum_{i=0}^{n-1} (k - 1) \cdot b^i = 1 + (k - 1) \frac{b^n - 1}{b - 1}$$ Trong đó $k$ là kích thước bộ lọc (kernel size), $b$ là cơ số giãn nở (dilation base, thường chọn $b=2$), $n$ là số lượng lớp tích chập.
Input Tensor: x0  x1  x2  x3  x4  x5  x6  x7  x8 (Lookback Sequence)
  • Khối dư (Residual Block): Mỗi khối dư gồm 2 lớp Dilated Causal Convolution, kết hợp hàm kích hoạt ReLU, Weight Normalization và Dropout (0.2) nhằm tránh hiện tượng bão hòa đạo hàm.
import torch
import torch.nn as nn
from bigdl.chronos.forecaster.tcn_forecaster import TCNForecaster

# Pipeline xây dựng mô hình TCN phân tán với BigDL Chronos
def create_distributed_tcn_forecaster(input_feature_num, output_horizon, lookback_window=12):
    """
    input_feature_num: Số lượng tuyến đường (Links) đầu vào
    output_horizon: Số bước thời gian cần dự báo (VD: 6 steps = 30 phút)
    lookback_window: Số bước thời gian lịch sử quan sát (VD: 12 steps = 60 phút)
    """
    forecaster = TCNForecaster(
        past_seq_len=lookback_window,
        future_seq_len=output_horizon,
        input_feature_num=input_feature_num,
        output_feature_num=input_feature_num,
        num_channels=[32, 64, 128],
        kernel_size=3,
        dilations=[1, 2, 4],
        dropout=0.2,
        lr=0.001,
        seed=42,
        distributed=True,
        workers_per_node=4
    )
    return forecaster

2. Pipeline tiền xử lý luồng dữ liệu trên Apache Spark

Dữ liệu thô từ NYC OpenData được đọc dưới dạng JSON stream, bóc tách các trường: DATA_AS_OF (mốc thời gian), LINK_ID (mã định danh đoạn đường) và SPEED (tốc độ thực tế). Dữ liệu được chuyển đổi sang bảng pivot ma trận không gian - thời gian:

from pyspark.sql import SparkSession
from pyspark.sql.functions import col, from_unixtime, unix_timestamp, avg

def process_traffic_stream(spark: SparkSession, raw_stream_df):
    # 1. Chuẩn hóa timestamp về định dạng 5 phút Resampling
    resampled_df = raw_stream_df.select(
        col("LINK_ID"),
        col("SPEED").cast("float"),
        (from_unixtime(unix_timestamp(col("DATA_AS_OF"), "MM/dd/yyyy HH:mm:ss") 
         - (unix_timestamp(col("DATA_AS_OF"), "MM/dd/yyyy HH:mm:ss") % 300))
        ).alias("INTERVAL_5MIN")
    )
    
    # 2. Gom nhóm tính tốc độ trung bình theo từng cửa sổ 5 phút
    aggregated_df = resampled_df.groupBy("INTERVAL_5MIN", "LINK_ID") \
        .agg(avg("SPEED").alias("AVG_SPEED"))
        
    # 3. Pivot ma trận: Index = Thời gian, Columns = LINK_ID
    matrix_df = aggregated_df.groupBy("INTERVAL_5MIN") \
        .pivot("LINK_ID") \
        .agg(avg("AVG_SPEED")) \
        .sort("INTERVAL_5MIN")
        
    return matrix_df

Đánh giá hiệu năng và Benchmark thực nghiệm

Hệ thống được thử nghiệm trên tập dữ liệu NYC Real Time Traffic Speed gồm hơn 50 triệu bản ghi, chia tập Train/Validation/Test theo tỷ lệ thời gian chuẩn 70:15:15.

1. Đánh giá sai số dự báo tại các mốc thời gian (Short-term vs Long-term)

Mô hình Sai số 5 phút (Short-term) Sai số 15 phút Sai số 30 phút Sai số 60 phút (Long-term) Thời gian huấn luyện (100 Epochs)
ARIMA (1, 1, 1) MAE: 4.82 | RMSE: 6.91 MAE: 7.45 | RMSE: 9.88 MAE: 10.12 | RMSE: 13.40 MAE: 14.85 | RMSE: 18.92 N/A (Fit từng series riêng lẻ)
Facebook Prophet MAE: 4.15 | RMSE: 5.88 MAE: 6.30 | RMSE: 8.42 MAE: 8.75 | RMSE: 11.20 MAE: 12.40 | RMSE: 15.65 ~ 4.2 giờ (Ray Tune search)
LSTM Network MAE: 2.85 | RMSE: 3.94 MAE: 4.10 | RMSE: 5.62 MAE: 5.80 | RMSE: 7.95 MAE: 8.25 | RMSE: 10.80 ~ 3.1 giờ (Spark Distributed)
TCN (Đề xuất) MAE: 2.12 | RMSE: 2.95 MAE: 3.05 | RMSE: 4.18 MAE: 4.25 | RMSE: 5.72 MAE: 6.10 | RMSE: 8.15 ~ 1.3 giờ (BigDL Distributed) 
MAE Error Comparison across Horizons (mph)
       5-min       15-min        30-min        60-min

2. Tác động của độ dài cửa sổ trượt quá khứ (Lookback Window) trên TCN

Thực nghiệm thay đổi Lookback Window ($L$) để đánh giá độ bao phủ thông tin:

  • $L = 6$ (30 phút trước): MAE đạt 2.65 mph (thiếu ngữ cảnh chu kỳ gần).
  • $L = 12$ (60 phút trước): MAE tối ưu đạt 2.12 mph (cân bằng hoàn hảo giữa độ chính xác và chi phí bộ nhớ).
  • $L = 24$ (120 phút trước): MAE đạt 2.10 mph (độ chính xác cải thiện không đáng kể 0.9%, nhưng chi phí tính toán tăng 45%).

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

Các cải tiến kỹ thuật nổi bật

  1. Kiến trúc End-to-End Big Data & Deep Learning thống nhất: Xóa bỏ rào cản phân mảnh giữa tầng lưu trữ dữ liệu lớn (Spark Data Lake) và tầng huấn luyện học sâu (PyTorch/TensorFlow). Dữ liệu được xử lý trực tiếp trong bộ nhớ (In-Memory Processing) mà không cần trích xuất thủ công ra đĩa cứng trung gian.
  2. Khắc phục triệt để hạn chế của RNN/LSTM trong bài toán chuỗi thời gian lớn: Ứng dụng TCN với cấu trúc tích chập 1 chiều mở rộng cho phép tính toán song song hoàn toàn ma trận thời gian. Tốc độ huấn luyện tăng 2.38 lần so với mạng LSTM phân tán trên cùng cấu hình phần cứng.
  3. Cơ chế Hyperparameter Tuning phân tán: Tích hợp module Chronos tự động tối ưu hóa siêu tham số của Prophet và TCN trên cụm phân tán Spark với quy mô 800 trials đồng thời.
+-----------------------------------------------------------------------------------+
|                            Prior Art Benchmarking Matrix                          |
+-----------------------------------------------------------------------------------+
| Study / System               | Architecture         | Dataset     | Metric (MAE)  |
+------------------------------+----------------------+-------------+---------------+
| Yisheng Lv et al. (2014)     | Stacked Autoencoders | PeMS (CA)   | 34.10 (15-min)|
| Rui Fu et al. (2016)         | Single LSTM / GRU    | PeMS (CA)   | 17.20 (5-min) |
| Yi Liu et al. (2020)         | FedGRU (Federated)   | PeMS 39K Sen| 6.84 (5-min)  |
| Quang Hung Do et al. (2018)  | FWNN-iBBO            | Local Hwy   | RMSE: 20.98   |
| **Khóa luận đề xuất (2021)** | **Distributed TCN**  | **NYC DOT** | **2.12 (5-min)** |
+-----------------------------------------------------------------------------------+

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

Kịch bản vận hành thực tế

  • Trung tâm điều hành giao thông đô thị thông minh (Smart City TMC): Tự động phát hiện điểm nóng ùn tắc trước 30-60 phút, tối ưu hóa chu kỳ đèn tín hiệu giao thông linh hoạt.
  • Hệ thống điều phối xe công nghệ & Logistics: Cung cấp thông tin Estimated Time of Arrival (ETA) chính xác cho các nền tảng đặt xe (Grab, Gojek, Uber) và đơn vị vận chuyển hàng hóa, giảm chi phí nhiên liệu và thời gian giao nhận.
                                   [ TCN Model Inference ]
       [ Dynamic Route Re-routing ]                        [ Heatmap UI Visualization ]
       (Logistics & Ride-Hailing API)                      (Traffic Management Center)

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

1. Yêu cầu tài nguyên hệ thống

  • Cụm Master/Worker Nodes: Tối thiểu 3 Nodes (1 Master, 2 Workers).
  • Phần cứng mỗi Node: CPU 8 Cores (Intel Xeon khuyến nghị), RAM 32 GB, Ổ cứng SSD 100 GB.
  • Môi trường: Ubuntu 20.04 LTS, Java JDK 8/11, Python 3.8.

2. Khởi chạy Pipeline xử lý và dự báo

# 1. Khởi động cụm Spark Standalone Cluster
$SPARK_HOME/sbin/start-master.sh
$SPARK_HOME/sbin/start-worker.sh spark://master-node:7077

# 2. Nộp Job Spark Streaming Ingestion & TCN Distributed Serving
spark-submit \
    --master spark://master-node:7077 \
    --driver-memory 8g \
    --executor-memory 16g \
    --executor-cores 4 \
    --conf spark.rpc.message.maxSize=512 \
    --py-files traffic_tcn_modules.zip \
    main_streaming_forecast.py \
    --input-stream-url "https://data.cityofnewyork.us/resource/i4gi-tjb9.json" \
    --model-path "hdfs://master-node:9000/models/tcn_traffic_v1.pt" \
    --lookback-window 12 \
    --forecast-horizon 6

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

Các hạn chế kỹ thuật hiện tại

  • Mô hình hóa không gian độc lập: TCN trích xuất đặc trưng thời gian (temporal) vượt trội nhưng mô hình hóa không gian (spatial) hiện dựa trên liên kết ma trận độc lập, chưa khai thác triệt để cấu trúc tô-pô mạng lưới đường giao thông dạng đồ thị.
  • Yếu tố ngoại sinh chưa tích hợp: Mô hình hiện thuần túy dựa trên chuỗi thời gian vận tốc; chưa kết hợp dữ liệu thời tiết cực đoan (mưa bão, tuyết rơi), sự kiện văn hóa xã hội đột xuất hay tai nạn giao thông cục bộ.

Định hướng nghiên cứu mở rộng

  • Mạng nơ-ron đồ thị không-thời gian (Spatio-Temporal Graph Neural Networks - STGCN): Kết hợp TCN với Graph Convolutional Networks (GCN) để mô hình hóa đồng thời cấu trúc liên kết đường phố dạng đồ thị không gian và chuỗi thời gian.
  • Tích hợp nguồn dữ liệu đa phương thức (Multimodal Data Fusion): Bổ sung dữ liệu sự kiện mạng xã hội, dữ liệu camera thị giác máy tính và thời tiết thực tế để tăng độ chính xác trong các tình huống dị biệt.

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

  [ Sinh viên ]      [ Lập trình viên ]      [ Doanh nghiệp ]   [ Nhà nghiên cứu ]
  Tài liệu học       Mẫu kiến trúc ETL/ML    Chiến lược giảm    Phương pháp luận
  Big Data + SOTA    chuẩn BigDL Spark       chi phí vận tải    chuỗi thời gian
  • Sinh viên ngành Khoa học Dữ liệu & CNTT: Nguồn tài liệu tham khảo hoàn chỉnh từ lý thuyết xử lý Big Data đến kỹ thuật triển khai mô hình Deep Learning SOTA.
  • Kỹ sư dữ liệu & Kỹ sư Machine Learning: Nắm vững mẫu kiến trúc (Design Pattern) tích hợp Apache Spark với BigDL/PyTorch để xử lý bài toán chuỗi thời gian phân tán.
  • Doanh nghiệp vận tải & Logistics: Khung tham chiếu để xây dựng hệ thống định tuyến tối ưu, giảm thiểu 15-20% thời gian trễ hành trình do tắc đường.
  • Cơ quan quản lý nhà nước: Giải pháp nền tảng phục vụ chuyển đổi số giao thông đô thị và xây dựng thành phố thông minh.

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

1. Yêu cầu phần cứng tối thiểu để triển khai giải pháp này là gì?

Hệ thống yêu cầu cụm máy chủ phân tán tối thiểu 1 Node Master và 2 Node Worker, mỗi Node trang bị CPU 8 Cores, RAM 32 GB. Đối với môi trường thử nghiệm đơn máy (Standalone Dev Mode), cần tối thiểu CPU 4 Cores, RAM 16 GB và cấu hình bộ nhớ cấp phát cho Spark Driver từ 8 GB trở lên.

2. Tại sao mô hình TCN lại có tốc độ huấn luyện nhanh hơn mạng LSTM?

Mạng LSTM có cấu trúc tuần tự (sequential cell-state dependency), bước tính toán tại thời điểm $t$ bắt buộc phải chờ kết quả từ thời điểm $t-1$. Ngược lại, TCN sử dụng tích chập 1D nhân quả trên toàn bộ chuỗi đầu vào, cho phép GPU/CPU tính toán song song đồng thời tất cả các bước thời gian (timesteps) trong batch, giúp giảm từ 40% đến 60% thời gian huấn luyện.

3. Hệ thống xử lý dữ liệu cảm biến bị mất hoặc trễ như thế nào?

Dữ liệu được làm sạch thông qua 2 giai đoạn:

  1. Resampling: Gom nhóm dữ liệu về các mốc cố định 5 phút bằng giá trị trung bình.
  2. Nội suy tuyến tính (Linear Interpolation): Với các cảm biến không gửi tín hiệu trong khung 5 phút, thuật toán nội suy dựa trên giá trị liền kề trước và sau để bù đắp điểm khuyết mà không làm biến dạng xu hướng chung của chuỗi.

4. BigDL 2.0 đóng vai trò gì trong kiến trúc này?

BigDL 2.0 đóng vai trò cầu nối cho phép chạy trực tiếp các framework học sâu tiêu chuẩn (PyTorch, TensorFlow) trên hạ tầng cụm Apache Spark. BigDL tự động hóa việc phân chia dữ liệu (Data Partitioning), quản lý vòng đời phân tán và đồng bộ trọng số thông qua cơ chế All-Reduce, loại bỏ sự phức tạp khi phải thiết lập các cụm GPU/Deep Learning độc lập.

5. Độ trễ dự báo (Inference Latency) của hệ thống có đáp ứng thời gian thực không?

Có. Trên cụm thực nghiệm 3 Nodes, thời gian tiền xử lý luồng một batch dữ liệu 5 phút trên toàn bộ các tuyến đường NYC mất khoảng 220ms; thời gian suy luận (Inference) của mô hình TCN mất dưới 80ms. Tổng độ trễ toàn trình là ~300ms, đáp ứng tiêu chuẩn phản hồi thời gian thực của hệ thống ITS.

Kết luận

Đồ án tốt nghiệp "Hệ thống dự báo luồng giao thông thời gian thực dựa trên phân tích dữ liệu lớn chuỗi thời gian" đã giải quyết trọn vẹn bài toán dự báo lưu lượng giao thông quy mô lớn. Bằng việc kết hợp sức mạnh xử lý luồng phân tán của Apache Spark, nền tảng học sâu phân tán BigDL 2.0 và kiến trúc Mạng tích chập thời gian (TCN), hệ thống đã chứng minh tính ưu việt vượt trội về độ chính xác (MAE 2.12 mph) và tốc độ huấn luyện so với các mô hình truyền thống (ARIMA, Prophet, LSTM).

Giải pháp mở ra tiềm năng ứng dụng thực tế to lớn cho các đô thị thông minh tại Việt Nam và trên thế giới, đặt nền móng vững chắc cho các nghiên cứu tiếp theo về mạng nơ-ron đồ thị không-thời gian.