Giới thiệu dự án

Ùn tắc giao thông (Traffic Congestion) là thách thức nan giải tại các đô thị lớn trên toàn cầu. Theo báo cáo thường niên của Viện Nghiên cứu Giao thông Texas (TTI) và Tổ chức Phân tích Giao thông INRIX, tắc nghẽn giao thông gây thiệt hại hàng trăm tỷ USD mỗi năm do lãng phí nhiên liệu, giảm năng suất lao động và phát thải khí nhà kính. Tại Việt Nam cũng như các siêu đô thị quốc tế, việc can thiệp hạ tầng vật lý (mở rộng cầu đường) đòi hỏi nguồn vốn khổng lồ và thời gian thi công kéo dài. Do đó, các giải pháp Ứng dụng Hệ thống Giao thông Thông minh (Intelligent Transportation Systems - ITS) dựa trên Công nghệ Dữ liệu lớn (Big Data) và Trí tuệ Nhân tạo (AI) trở thành hướng tiếp cận đột phá.

Vấn đề cốt lõi của bài toán dự báo giao thông truyền thống nằm ở tính biến động phi tuyến, độ trễ thu thập dữ liệu và sự phụ thuộc không gian - thời gian (Spatial-Temporal Dependencies) giữa các nút giao thông liền kề. Khóa luận tốt nghiệp "Hệ thống dự đoán kẹt xe thời gian thực sử dụng công nghệ dữ liệu lớn" của tác giả Nguyễn Hoài Phương Uyên (Trường Đại học Công nghệ Thông tin – ĐHQG TP.HCM, dưới sự hướng dẫn của TS. Đỗ Trọng Hợp và ThS. Phạm Thế Sơn) giải quyết bài toán này bằng cách kết hợp xử lý luồng dữ liệu thời gian thực và mô hình học máy lai (Hybrid Time-series Forecasting).

                    +-------------------------------------------------+
                    |     Nguồn dữ liệu GPS xe buýt Chicago Tracker   |
                    +-------------------------------------------------+
                                             |
                                             v
                    +-------------------------------------------------+
                    |  Apache Kafka Message Broker (Topic Ingestion)  |
                    +-------------------------------------------------+
                                             |
                                             v
                    +-------------------------------------------------+
                    | Apache Spark Structured Streaming (Tiền xử lý)  |
                    +-------------------------------------------------+
                                             |
                    +------------------------+------------------------+
                    |                                                 |
                    v                                                 v
  +-----------------------------------+             +-----------------------------------+
  |    Mô hình ngắn hạn (SARIMAX)     |             |    Mô hình dài hạn (FB Prophet)   |
  +-----------------------------------+             +-----------------------------------+
                    |                                                 |
                    +------------------------+------------------------+
                                             |
                                             v
                    +-------------------------------------------------+
                    |   Mô hình Stacking Hồi quy Tuyến tính Meta-Model|
                    |   (Tích hợp v8(t), v9(t), v10(t) & Dự báo)      |
                    +-------------------------------------------------+
                                             |
                                             v
                    +-------------------------------------------------+
                    |   Dự báo tốc độ và cảnh báo kẹt xe Real-Time    |
                    +-------------------------------------------------+

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

  1. Xây dựng luồng thu thập và tiền xử lý dữ liệu luồng (Data Streaming Pipeline) với độ trễ thấp sử dụng Apache Kafka và Apache Spark Structured Streaming.
  2. Thiết lập quy chuẩn xử lý chuỗi thời gian đối với dữ liệu cảm biến GPS bị nhiễu, xử lý khuyết thiếu (missing data) và chuẩn hóa khung thời gian 15 phút.
  3. Nghiên cứu và huấn luyện hai mô hình chuỗi thời gian: SARIMAX (dự báo ngắn hạn, xử lý tính mùa vụ theo chu kỳ ngày/tuần) và Facebook Prophet (dự báo dài hạn, trích xuất xu hướng vĩ mô).
  4. Xây dựng mô hình hồi quy tổng hợp (Meta-Learning Regression) kết hợp kết quả dự báo của SARIMAX, Facebook Prophet cùng vận tốc thực tế tại thời điểm $t$ của đoạn đường mục tiêu và các đoạn đường lân cận (Spatial Context).
  5. Tối ưu hóa sai số dự báo đạt chỉ số $RMSE \approx 2.0$, cung cấp kết quả phục vụ điều phối giao thông tự động.

Phạm vi nghiên cứu tập trung trên tập dữ liệu giao thông mở của Sở Giao thông Vận tải Chicago (Chicago Traffic Tracker), phân tích chi tiết trục đường Garfield Boulevard (Hướng Đông - Eastbound) qua 3 đoạn đường liên tiếp: Segment 8 (Racine đến Halsted), Segment 9 (Halsted đến Dan Ryan Expressway - đoạn mục tiêu), và Segment 10 (Dan Ryan Expressway đến State).

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

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

Các phương pháp dự đoán tình trạng giao thông hiện hành chủ yếu chia làm 3 nhóm chính: thống kê truyền thống, máy học đơn lẻ và trích xuất dữ liệu đám đông (Crowdsourcing).

Giải pháp Nguyên lý hoạt động Ưu điểm Nhược điểm
UTraffic (ĐH Bách Khoa TP.HCM) Khai thác dữ liệu đám đông từ người dùng Mobile App/Web kết hợp GPS. Phản ánh trực tiếp trải nghiệm người dùng nội đô. Độ phủ phụ thuộc lượng người dùng kích hoạt app; dữ liệu rời rạc, tính nhất quán thấp.
Storm + SVM (Highway Traffic) Xử lý luồng bằng Apache Storm, phân lớp kẹt xe bằng Support Vector Machine. Khả năng xử lý thời gian thực tốt trên cao tốc. SVM gặp khó khăn trong việc nắm bắt tính mùa vụ phức tạp của chuỗi thời gian dài hạn.
ARIMA truyền thống Hồi quy tự tương quan chuỗi thời gian ngắn hạn (1-3 ngày lịch sử). Cấu trúc toán học chặt chẽ, huấn luyện nhanh. Bỏ qua xu hướng dài hạn (trend) và hoàn toàn triệt tiêu yếu tố không gian (Spatial dependencies).

Yêu cầu người dùng và hệ thống được phân loại theo ma trận MoSCoW:

  • Must Have (Bắt buộc): Pipeline thu thập dữ liệu tự động chu kỳ 15 phút qua REST API; Xử lý giá trị lỗi (-1) và dữ liệu rỗng; Dự báo tốc độ đoạn đường mục tiêu theo thời gian thực.
  • Should Have (Nên có): Tích hợp thông tin vận tốc từ các đoạn đường lân cận (Upstream/Downstream) để tăng độ chính xác; Mô hình hóa đa khung thời gian (ngắn hạn + dài hạn).
  • Could Have (Có thể có): Giao diện Dashboard trực quan hóa bản đồ nhiệt (Heatmap) giao thông; Tích hợp dữ liệu thời tiết và sự kiện đô thị.
  • Won't Have (Chưa thực hiện): Tự động điều khiển chu kỳ đèn tín hiệu giao thông thời gian thực.

Thiết kế hệ thống

Kiến trúc hệ thống được xây dựng trên mô hình Publish-Subscribe phân tán kết hợp Micro-batching Stream Processing:

[Chicago Traffic API] ---> [Kafka Producer] ---> [Kafka Cluster (Topics: raw_traffic)]
                                                              |
                                                              v
[Kafka Topic: clean_traffic] <--- [Spark Structured Streaming (Transformation & Lag)]
         |
         v
[Real-time Inference Engine (SARIMAX + Prophet + Linear Regression)]
         |
         v
[Downstream Consumers / Alert Dispatcher / Real-time Storage]

Technology Stack chi tiết:

  • Ngôn ngữ lập trình: Python 3.8.10 (phân tích, huấn luyện và kịch bản streaming).
  • Phân tán & Hàng đợi thông điệp: Apache Kafka 2.8.0, Apache Zookeeper 3.6.3.
  • Xử lý luồng dữ liệu: Apache Spark 3.1.2 (Spark Structured Streaming, PySpark SQL).
  • Mô hình chuỗi thời gian & Học máy: Statsmodels 0.13.2 (SARIMAX), Facebook Prophet 1.0, Scikit-learn 0.24.2 (Linear Regression, Metrics).
  • Thư viện khoa học dữ liệu: Pandas 1.3.3, NumPy 1.21.2, Matplotlib 3.4.3.

Kiến trúc dữ liệu luồng sử dụng cấu trúc schema JSON chuẩn hóa từ API:

{
  "segmentid": "9",
  "street": "Garfield",
  "direction": "EB",
  "fromst": "Halsted",
  "tost": "Dan Ryan Expy",
  "length": "0.72",
  "traffic": "29",
  "last_updt": "2022-01-26 08:50:38.0"
}

Methodology

Phương pháp luận phát triển tuân theo chuẩn quy trình CRISP-DM (Cross-Industry Standard Process for Data Mining) chuyên sâu cho dữ liệu chuỗi thời gian:

  1. Thu thập dữ liệu lịch sử: Trích xuất dữ liệu từ tháng 03/2018 đến 24/10/2021 của 3 phân đoạn 8, 9, 10 từ tập dữ liệu Chicago Traffic Tracker - Historical Congestion Estimates by Segment.
  2. Tiền xử lý & Nội suy chuỗi: Chuẩn hóa bước nhảy thời gian về chu kỳ cố định 15 phút. Loại bỏ giá trị không hợp lệ ($traffic = -1$). Áp dụng kỹ thuật nội suy tuyến tính (Linear Interpolation) để lấp đầy các khoảng trống dữ liệu khi xe buýt không phát tín hiệu GPS.
  3. Phát triển mô hình thành phần (Component Models):
    • SARIMAX: Cấu hình $(p, d, q) \times (P, D, Q)_s$ nhằm nắm bắt tự tương quan ngắn hạn và tính mùa vụ chu kỳ 24 giờ / 7 ngày.
    • Facebook Prophet: Phân rã chuỗi thời gian thành xu hướng $g(t)$, mùa vụ $s(t)$, ngày lễ $h(t)$ và sai số $\epsilon_t$.
  4. Xây dựng Meta-Model Stacking: Đào tạo hồi quy tuyến tính nhận đầu vào gồm: $\hat{y}{\text{SARIMAX}}$, $\hat{y}{\text{Prophet}}$, $v_{8}(t)$, $v_{9}(t)$, $v_{10}(t)$ để dự báo $v_{9}(t+1)$.
  5. Đánh giá kiểm thử: Sử dụng chỉ số sai số toàn phương trung bình chuẩn hóa Root Mean Squared Error ($RMSE$).

$$\text{RMSE} = \sqrt{\frac{1}{n} \sum_{i=1}^{n} (y_i - \hat{y}_i)^2}$$

Implementation và kết quả

Development process

Quá trình cài đặt hệ thống bao gồm ba module trọng tâm: Ingestion, Streaming Transformation và Ensemble Inference.

1. Thu thập dữ liệu luồng với Kafka Producer:

import json
import time
import requests
from kafka import KafkaProducer

producer = KafkaProducer(
    bootstrap_servers=['localhost:9092'],
    value_serializer=lambda v: json.dumps(v).encode('utf-8')
)

API_URL = "https://data.cityofchicago.org/resource/8v9j-7ky6.json"
TARGET_SEGMENTS = {'8', '9', '10'}

def fetch_and_publish():
    while True:
        try:
            response = requests.get(API_URL, timeout=10)
            if response.status_code == 200:
                data = response.json()
                for item in data:
                    if item.get('segmentid') in TARGET_SEGMENTS:
                        producer.send('raw_traffic_stream', value=item)
                producer.flush()
        except Exception as e:
            print(f"Error fetching data: {str(e)}")
        time.sleep(900)  # Chu kỳ 15 phút

if __name__ == '__main__':
    fetch_and_publish()

2. Tiền xử lý thời gian thực với Spark Structured Streaming:

Quy tắc làm tròn thời gian thực về mốc cố định: Các giá trị phút thuộc khoảng $[1, 14] \to 15$, $[16, 29] \to 30$, $[31, 44] \to 45$, $[46, 59] \to 00$ (cộng thêm 1 giờ).

from pyspark.sql import SparkSession
from pyspark.sql.functions import from_json, col, when, minute, hour, to_timestamp
from pyspark.sql.types import StructType, StringType

schema = StructType() \
    .add("segmentid", StringType()) \
    .add("traffic", StringType()) \
    .add("last_updt", StringType())

spark = SparkSession.builder \
    .appName("TrafficStreamingPreprocessor") \
    .master("local[*]") \
    .getOrCreate()

raw_stream = spark.readStream \
    .format("kafka") \
    .option("kafka.bootstrap.servers", "localhost:9092") \
    .option("subscribe", "raw_traffic_stream") \
    .load()

parsed_stream = raw_stream.selectExpr("CAST(value AS STRING)") \
    .select(from_json(col("value"), schema).alias("data")) \
    .select("data.*") \
    .filter(col("traffic") != "-1")

# Chuẩn hóa thời gian về chu kỳ 15 phút
processed_stream = parsed_stream.withColumn(
    "speed", col("traffic").cast("float")
).withColumn(
    "timestamp", to_timestamp(col("last_updt"), "yyyy-MM-dd HH:mm:ss.S")
)

3. Huấn luyện mô hình tổng hợp (Ensemble Stacking Model):

Dữ liệu huấn luyện mô hình Meta-Model được tạo bằng kỹ thuật trễ thời gian 1 bậc (Lag-1) trên tập dữ liệu đã đồng bộ của 3 phân đoạn:

import numpy as np
from sklearn.linear_model import LinearRegression

# X_train cấu tạo từ: [SARIMAX_pred, Prophet_pred, V8_current, V9_current, V10_current]
# Y_train: V9_future (Tốc độ thực tế ở thời điểm t+15 phút)

meta_model = LinearRegression(fit_intercept=True)
meta_model.fit(X_train, y_train)

# Công thức hồi quy thu được
weights = meta_model.coef_
bias = meta_model.intercept_
print(f"Meta-Model Formula: v9(t+1) = {bias:.4f} + {weights[0]:.4f}*y_sari + {weights[1]:.4f}*y_prophet + {weights[2]:.4f}*v8 + {weights[3]:.4f}*v9 + {weights[4]:.4f}*v10")

Testing và validation

Quá trình kiểm thử được thực hiện trên tập kiểm thử độc lập (thời gian từ cuối năm 2021 đến đầu năm 2022). Tập dữ liệu được kiểm định nghiêm ngặt qua các trường hợp thiếu dữ liệu, nhiễu GPS và độ trễ ngẫu nhiên của mạng.

Mô hình kiểm thử Đặc trưng đầu vào RMSE (mph) Đánh giá hiệu năng
SARIMAX Đơn lẻ Lịch sử chuỗi thời gian Segment 9 $4.85$ Bắt tốt biến động tức thời, nhạy cảm với nhiễu ngắn hạn.
Prophet Đơn lẻ Lịch sử chuỗi thời gian Segment 9 $5.12$ Bắt tốt đường xu hướng chung, bỏ sót đột biến tức thời.
SARIMAX + Prophet Kết hợp 2 dự báo không có lân cận $3.64$ Cải thiện sai số, cân bằng giữa xu hướng và chu kỳ.
Hybrid Stacking (Đề xuất) SARIMAX + Prophet + V8(t) + V9(t) + V10(t) 2.08 Độ chính xác vượt trội nhờ bổ sung bối cảnh không gian.

Kết quả đạt được

Hệ thống đã hoàn thành trọn vẹn các yêu cầu thiết kế ban đầu:

  • Độ chính xác dự báo: Chỉ số RMSE giảm từ mức $4.85 - 5.12$ của các mô hình đơn lẻ xuống còn $2.08$ đối với mô hình tổng hợp đề xuất (giảm hơn $57%$ sai số dự báo).
  • Hiệu năng thời gian thực: Luồng Spark Structured Streaming và Kafka đạt thông lượng xử lý trung bình dưới $1.2$ giây cho mỗi micro-batch dữ liệu.
  • Tính ổn định: Hệ thống hoạt động liên tục, tự động làm tròn khung thời gian và bù khuyết dữ liệu thông qua cơ chế nội suy mà không cần can thiệp thủ công.

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

  1. Kết hợp Đa Chiều Không Gian - Thời Gian (Spatial-Temporal Fusion): Thay vì chỉ xem xét chuỗi thời gian độc lập của một phân đoạn, nghiên cứu tích hợp vận tốc thực tế tại thời điểm $t$ của cả phân đoạn thượng lưu (Segment 8) và hạ lưu (Segment 10). Thực nghiệm chứng minh hiện tượng dồn ứ hoặc giải tỏa giao thông tại hai đầu có mối tương quan tuyến tính chặt chẽ đến tốc độ đoạn giữa ở bước thời gian tiếp theo.

  2. Kiến trúc Stacking Đa Tầm Dự Báo (Multi-Horizon Hybrid Model): Tận dụng thế mạnh phân tích tần số ngắn hạn của SARIMAX và khả năng mô hình hóa thành phần phi tuyến tính, ngày nghỉ/lễ dài hạn của Facebook Prophet thông qua một mô hình hồi quy Meta-Model có trọng số động.

  3. Pipeline Dữ Liệu Lớn Hoàn Chỉnh End-to-End: Hiện thực hóa việc chuyển giao từ nghiên cứu mô hình hóa lý thuyết sang kiến trúc kỹ thuật phần mềm có khả năng mở rộng (Scalable Architecture) bằng việc tích hợp Apache Spark Structured Streaming và Apache Kafka.

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

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

+-------------------------------------------------------------------------+
|                  TRUNG TÂM ĐIỀU HÀNH GIAO THÔNG ĐÔ THỊ                  |
|                                                                         |
|  [Hệ thống Dự báo Real-Time] -> Phát hiện Segment 9: Tốc độ < 10 mph    |
|                                 (Cảnh báo kẹt xe trước 15-30 phút)      |
+-------------------------------------------------------------------------+
       |                                                   |
       v                                                   v
+------------------------------------+  +---------------------------------+
|   ĐIỀU PHỐI LỰC LƯỢNG CSGT         |  |   HỆ THỐNG ĐIỀU HƯỚNG XE        |
|                                    |  |                                 |
| - Điều động CSGT can thiệp sớm     |  | - Cập nhật Dynamic Routing      |
| - Tránh nghẽn lan tỏa toàn tuyến   |  | - Hướng dẫn xe chuyển hướng     |
+------------------------------------+  +---------------------------------+
  • Điều phối Giao thông Đô thị Thông minh: Cung cấp thông tin cảnh báo sớm trước 15–30 phút cho Trung tâm Quản lý Điều hành Giao thông Đô thị (TMC) để lực lượng Cảnh sát Giao thông kịp thời có mặt tại nút giao trước khi ùn tắc chuyển sang mức tê liệt hoàn toàn.
  • Tích hợp API Định tuyến Động (Dynamic Routing): Cung cấp API dự báo vận tốc cho các ứng dụng bản đồ (như Google Maps, Grab, Gojek) nhằm gợi ý tuyến đường thay thế tối ưu dựa trên vận tốc dự kiến trong tương lai thay vì vận tốc tĩnh hiện tại.

Cấu hình triển khai hệ thống

  • Môi trường Server tối thiểu:
    • CPU: 8 Cores (Intel Xeon hoặc AMD EPYC).
    • RAM: 32 GB (Đảm bảo bộ nhớ in-memory cho Spark RDD/DataFrame và Kafka Buffer).
    • Ổ cứng: 256 GB SSD NVMe.
    • OS: Ubuntu Server 20.04 LTS / CentOS 8.
  • Mở rộng quy mô (Scalability):
    • Mở rộng phân vùng Kafka (Partitions) tương ứng với số lượng quận/huyện trong thành phố.
    • Cụm Spark chạy trên nền tảng quản lý tài nguyên Kubernetes hoặc Hadoop YARN, cho phép tự động tăng số lượng Executor Nodes khi quy mô giám sát mở rộng lên hàng nghìn nút giao thông.

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

Hạn chế kỹ thuật

  • Nguồn dữ liệu đơn lẻ: Hệ thống phụ thuộc chủ yếu vào tín hiệu GPS từ xe buýt công cộng, do đó tại các khung giờ đêm muộn khi tần suất xe buýt giảm, dữ liệu bị thưa thớt (sparse data).
  • Chưa tính toán biến số ngoại cảnh: Chưa đưa trực tiếp các đặc trưng thời tiết (mưa, ngập nước, tuyết rơi) và sự kiện bất thường (tai nạn, công trình thi công) vào ma trận trọng số.

Hướng phát triển

  1. Nâng cấp mô hình Deep Learning: Nghiên cứu áp dụng mạng nơ-ron đồ thị không gian - thời gian (Spatio-Temporal Graph Neural Networks - STGNN) và kiến trúc Transformer (Temporal Fusion Transformer) để tự động hóa trích xuất đặc trưng mạng lưới đường phố phức tạp.
  2. Đa dạng hóa nguồn dữ liệu: Tích hợp thêm dữ liệu Camera giao thông (Computer Vision Vehicle Counting), dữ liệu từ các thiết bị IoT cảm biến gắn tại mặt đường và dữ liệu báo cáo sự cố từ cộng đồng.

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

  • Sinh viên & Học viên cao học: Tham khảo kiến trúc chuẩn để triển khai các bài toán Xử lý Dữ liệu lớn kết hợp Học máy và Kỹ thuật Chuỗi thời gian.
  • Kỹ sư Dữ liệu (Data Engineers) & ML Engineers: Nắm vững mẫu thiết kế (Design Pattern) tích hợp giữa Kafka Producer/Consumer, Spark Structured Streaming và mô hình Machine Learning Inference thời gian thực.
  • Doanh nghiệp Vận tải & Logistics: Tối ưu hóa lộ trình giao hàng, giảm thiểu thời gian chờ, tiết kiệm chi phí nhiên liệu và nâng cao độ chính xác của thời gian giao hàng dự kiến (Estimated Time of Arrival - ETA).
  • Cơ quan Quản lý Nhà nước: Có công cụ khoa học hỗ trợ quy hoạch hạ tầng và điều phối giao thông thông minh dựa trên dữ liệu định lượng.

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

1. Yêu cầu phần cứng và phần mềm tối thiểu để triển khai pipeline này là gì?

Để triển khai thử nghiệm hệ thống cho một tuyến đường cục bộ, cần máy chủ chạy hệ điều hành Linux (Ubuntu 20.04/22.04 LTS), tối thiểu 4 Core CPU, 16 GB RAM và 50 GB dung lượng đĩa trống. Môi trường phần mềm yêu cầu cài đặt Java OpenJDK 8/11 (phục vụ Kafka và Spark), Python 3.8+ cùng các gói phụ thuộc pyspark, kafka-python, statsmodels, prophet và scikit-learn.

2. Hệ thống xử lý như thế nào khi gặp sự cố mất tín hiệu GPS hoặc dữ liệu trả về giá trị -1?

Pipeline xử lý dữ liệu được thiết kế hai tầng phòng vệ: Tại tầng Spark Structured Streaming, các bản ghi có giá trị tốc độ $-1$ được lọc bỏ ngay lập tức. Sau đó, tại bước chuẩn hóa cửa sổ thời gian 15 phút, hệ thống sử dụng thuật toán nội suy chuỗi thời gian tuyến tính (Linear Time-series Interpolation) dựa trên các giá trị hợp lệ liền trước và liền sau để tái tạo dữ liệu bị thiếu trước khi đưa vào mô hình dự báo.

3. Có thể mở rộng hệ thống để dự báo cho toàn bộ mạng lưới hàng nghìn đoạn đường không?

Hoàn toàn khả thi. Do hệ thống được xây dựng trên nền tảng kiến trúc phân tán của Kafka và Spark, khả năng mở rộng ngang (Horizontal Scalability) được đảm bảo. Ta có thể tăng số lượng Kafka Partitions và mở rộng Spark Cluster Worker Nodes. Đối với phần mô hình, các đoạn đường có thể được nhóm lại theo cụm địa lý (Clustering) hoặc chuyển đổi sang mô hình Đồ thị Không gian - Thời gian (STGCN) để xử lý ma trận toàn thành phố.

4. Tại sao lại chọn chu kỳ dự báo là 15 phút mà không phải là 1 phút hay 60 phút?

Chu kỳ 15 phút được lựa chọn dựa trên sự cân bằng tối ưu giữa: (1) Tần suất cập nhật thực tế của nguồn dữ liệu GPS xe buýt từ Chicago Traffic Tracker (trung bình 10–15 phút/lần); (2) Đủ thời gian cho các lực lượng chức năng hoặc tài xế đưa ra quyết định chuyển hướng; (3) Giảm thiểu hiện tượng nhiễu xung đột tức thời (High-frequency noise) nếu lấy chu kỳ quá ngắn (1 phút).

5. Chi phí vận hành hạ tầng đám mây cho hệ thống này ước tính khoảng bao nhiêu?

Nếu triển khai trên các nhà cung cấp đám mây lớn (như AWS hoặc GCP) sử dụng các dịch vụ quản lý như Amazon MSK (Kafka) và Amazon EMR (Spark), chi phí ước tính dao động từ $150 - $350 USD/tháng cho quy mô một khu vực đô thị trung bình. Chi phí này có thể tối ưu hóa đáng kể bằng cách sử dụng các máy ảo Spot Instances hoặc tự vận hành cụm máy chủ vật lý riêng (On-premise).

Kết luận

Khóa luận "Hệ thống dự đoán kẹt xe thời gian thực sử dụng công nghệ dữ liệu lớn" của tác giả Nguyễn Hoài Phương Uyên là một công trình nghiên cứu ứng dụng toàn diện, giải quyết trọn vẹn từ khâu thu thập, tiền xử lý luồng dữ liệu lớn đến việc tối ưu hóa thuật toán học máy dự báo chuỗi thời gian. Bằng cách sáng tạo kết hợp giữa mô hình chuỗi thời gian ngắn hạn (SARIMAX), dài hạn (Facebook Prophet) cùng bối cảnh không gian thực tế của các đoạn đường lân cận, hệ thống đã hạ thấp sai số $RMSE$ xuống mức $2.08$, mang lại giá trị thực tiễn cao cho bài toán giao thông thông minh. Đây là tài liệu tham khảo giá trị cho các kỹ sư, nhà nghiên cứu đang phát triển các giải pháp phân tích dữ liệu lớn và học máy phục vụ đô thị thông minh.