Giới thiệu dự án

Trong kỷ nguyên Công nghiệp 4.0 và sự bùng nổ của Internet vạn vật (IoT), hệ thống giám sát an ninh (CCTV) đang trải qua bước chuyển dịch mang tính bước ngoặt từ quan sát thụ động sang phân tích chủ động dựa trên Trí tuệ nhân tạo (AI). Theo các báo cáo thị trường phân tích video toàn cầu, khối lượng dữ liệu thị giác được tạo ra mỗi giây từ hàng triệu thiết bị ghi hình vượt quá khả năng xử lý thủ công của con người. Các mô hình giám sát truyền thống bộc lộ những "điểm nghẽn" (bottlenecks) nghiêm trọng: phụ thuộc hoàn toàn vào nhân lực giám sát liên tục, tỷ lệ bỏ sót cảnh báo cao khi mệt mỏi, và độ trễ phản ứng lớn trước các sự cố an ninh.

Tuy nhiên, việc triển khai các mô hình học sâu (Deep Learning) trực tiếp vào luồng video thời gian thực từ nhiều camera đồng thời đặt ra bài toán hóc búa về kiến trúc phần mềm: làm thế nào để xử lý dữ liệu video đa luồng, lưu lượng lớn mà không gây nghẽn hàng đợi (queue blocking), drop khung hình (frame drops) hoặc quá tải tài nguyên tính toán.

Đề tài "Xây dựng hệ thống xử lý đa luồng kết hợp với AI cho hệ thống camera giám sát thông minh" do sinh viên Vũ Đức Duy (Khoa Công nghệ Thông tin Việt - Nhật, Trường Đại học Phenikaa; GVHD: TS. Phạm Tiến Lâm) thực hiện nhằm giải quyết trực tiếp bài toán tích hợp giữa nền tảng streaming phân tán và các mô hình thị giác máy tính hiện đại.

+-----------------------------------------------------------------------------+
|                               MỤC TIÊU DỰ ÁN                                |
+-----------------------------------------------------------------------------+
| 1. Xây dựng pipeline xử lý đa luồng (Multi-threading) phân tán qua Kafka   |
| 2. Nhận diện và đếm số lượng người thời gian thực (Face/Person Detection)   |
| 3. Trực quan hóa dữ liệu qua Web Dashboard tương tác (WebSocket + Plotly)   |
| 4. Lưu trữ tài liệu phi cấu trúc và siêu dữ liệu hình ảnh trên MongoDB NoSQL|
+-----------------------------------------------------------------------------+

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

  1. Phát triển hệ thống xử lý đa luồng phân tán: Xây dựng cơ chế tiếp nhận và đồng bộ luồng dữ liệu song song từ 2 nguồn camera (Camera tích hợp trên Laptop và Camera ngoại vi Logitech USB) sử dụng nền tảng Apache Kafka làm Event Broker trung gian.
  2. Tích hợp mô hình AI nhận diện và đếm người: Ứng dụng các kỹ thuật thị giác máy tính và học sâu (Face Detection/Recognition) nhằm phát hiện chính xác sự xuất hiện của đối tượng người trong từng khung hình video theo thời gian thực.
  3. Phát triển Dashboard giám sát thời gian thực: Xây dựng ứng dụng Web trên nền tảng Flask Framework, đồng bộ dữ liệu thống kê hai chiều thông qua WebSocket và hiển thị biểu đồ biến thiên mật độ người theo trục thời gian với Plotly.
  4. Quản trị và lưu trữ dữ liệu thông minh: Thiết kế cơ sở dữ liệu NoSQL MongoDB để lưu trữ metadata nhận diện, thông tin định danh camera, timestamp và trích xuất lưu trữ khung hình chứa khuôn mặt vào bộ nhớ máy chủ.

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

  • Phạm vi triển khai: Hệ thống thực nghiệm trên môi trường máy chủ cục bộ hệ điều hành Ubuntu Linux, tích hợp ảo hóa container với Docker, nhận diện đồng thời 2 luồng camera vật lý với độ phân giải HD.
  • Giới hạn: Tập trung giải quyết bài toán phát hiện khuôn mặt/người và đếm mật độ trong khung hình tĩnh/động; chưa mở rộng sang bài toán theo dõi đa mục tiêu xuyên camera (Multi-Camera Multi-Target Tracking - MCMT) hoặc phân tích hành vi phức tạp (Anomaly Detection).

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

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

Trước khi thiết kế kiến trúc, nhóm nghiên cứu đã đánh giá so sánh giữa 3 hướng tiếp cận phổ biến trong xử lý video phân tích AI:

Tiêu chí Mô hình Monolithic (Xử lý đơn luồng OpenCV) Mô hình Client-Server truyền thống qua HTTP/REST Giải pháp đề xuất (Kafka Event-Driven + Microservices)
Cơ chế truyền tải Vòng lặp cv2.VideoCapture đồng bộ Gửi frame qua HTTP POST Polling Publish/Subscribe phân tán qua Kafka Brokers
Độ trễ (Latency) Tăng tuyến tính theo số lượng camera ($O(N)$) Cao do HTTP overhead (TCP handshakes) Thấp (< 100ms), truyền dữ liệu binary stream
Khả năng mở rộng Rất kém, giới hạn bởi tài nguyên 1 CPU process Trung bình, dễ quá tải Web Server Cực cao, mở rộng ngang (Horizontal Scaling) qua Partitions
Khả năng chịu lỗi Tiến trình chết làm sập toàn bộ hệ thống Dễ mất mát gói tin khi nghẽn mạng Bền vững (Data Persistence) qua Kafka Log và Replicas
Tính linh hoạt Khó tích hợp thêm module phân tích mới Khó cập nhật API theo thời gian thực Rất dễ dàng thêm Consumers xử lý AI độc lập

Phân loại yêu cầu theo mô hình MoSCoW

  • Must Have (Bắt buộc phải có): Tiếp nhận đồng thời 2 luồng video (camera_laptop1, camera_logitech1); phát hiện khuôn mặt và đếm người; đẩy dữ liệu vào MongoDB; stream hình ảnh trực tiếp lên Web UI.
  • Should Have (Nên có): Biểu đồ Plotly tương tác cập nhật không cần tải lại trang (F5) qua WebSocket; cấu hình triển khai nhanh bằng Docker Compose; lưu trữ file ảnh cắt khuôn mặt cục bộ.
  • Could Have (Có thể mở rộng): Tự động cảnh báo khi số lượng người vượt ngưỡng an toàn; lọc tìm kiếm lịch sử frame ảnh theo khoảng thời gian.
  • Won't Have (Chưa thực hiện đợt này): Nhận diện danh tính cụ thể từng cá nhân (Face Verification 1:N với cơ sở dữ liệu hàng triệu người) và phân tích cảm xúc (Emotion Recognition).

Thiết kế hệ thống

Kiến trúc hệ thống được xây dựng theo mô hình Event-Driven Microservices Architecture, tách biệt hoàn toàn giữa tầng thu nhận dữ liệu (Ingestion Layer), tầng trung gian thông điệp (Messaging Layer), tầng xử lý phân tích AI (Processing Layer) và tầng hiển thị/lưu trữ (Presentation & Storage Layer).

                      +-----------------------------+
                      |   Camera Sources (Ingest)   |
                      | - Laptop Camera             |
                      | - Logitech USB Camera       |
                      +--------------+--------------+
                                     |
                          [Video Frame Capture]
                                     |
                                     v
                      +-----------------------------+
                      |   Apache Kafka Producers    |
                      +--------------+--------------+
                                     |
                                (Topics)
                        /-----------------------\
                       |  camera_laptop1 (P=3)   |
                       |  camera_logitech1 (P=3) |
                        \-----------------------/
                                     |
                                     v
                      +-----------------------------+
                      |   Apache Kafka Consumers    |
                      | (AI Inference & Detection)  |
                      | - Face/Person Detection     |
                      | - Bounding Box Calculation  |
                      | - Frame Image Saver         |
                      +-------+--------------+------+
                              |              |
                      (JSON / Metrics)   (Raw Frame Data)
                              |              |
                              v              v
     +--------------------------+          +--------------------------+
     |   MongoDB Database       |          |   Flask Web Server       |
     | - Collection: detections |          | - WebSocket Handlers     |
     | - JSON Metadata Logging  |          | - Plotly Real-time Chart |
     +--------------------------+          +--------------------------+

Chi tiết Tech Stack và Phiên bản công nghệ

  • Hệ điều hành nền tảng: Ubuntu 20.04/22.04 LTS (x86_64).
  • Ngôn ngữ phát triển: Python 3.9+ (Thư viện: opencv-python, kafka-python, flask, flask-socketio, pymongo, numpy).
  • Nền tảng ảo hóa & Điều phối: Docker Engine 24.x, Docker Compose v2.x.
  • Hệ thống hàng đợi phân tán: Apache Kafka (Image: wurstmeister/kafka hoặc Confluent Platform) kết hợp Apache Zookeeper điều phối metadata.
  • Cơ sở dữ liệu NoSQL: MongoDB 6.0 Server (Chạy trên cổng mặc định 27017).
  • Giao diện & Trực quan hóa: Flask Web Framework, Socket.IO Client, Plotly JavaScript.

Thiết kế cấu trúc dữ liệu MongoDB (Document Schema)

Mỗi sự kiện nhận diện từ các Consumer được chuẩn hóa dưới định dạng JSON/BSON và lưu vào collection camera_detections:

{
  "_id": {"$oid": "65163ab49a3e21001f5c49b1"},
  "camera_id": "camera_logitech1",
  "timestamp": "2023-09-29T10:15:32.450Z",
  "total_persons_detected": 3,
  "detection_details": [
    {
      "box_id": 1,
      "coordinates": {"x": 120, "y": 85, "width": 64, "height": 80},
      "confidence": 0.94
    },
    {
      "box_id": 2,
      "coordinates": {"x": 310, "y": 92, "width": 60, "height": 78},
      "confidence": 0.89
    }
  ],
  "saved_image_path": "/var/data/frames/camera_logitech1_20230929_101532.jpg"
}

Phương pháp nghiên cứu và quy trình thực hiện

Quy trình nghiên cứu áp dụng phương pháp phát triển linh hoạt (Iterative Agile) chia thành các giai đoạn (Milestones):

  • Giai đoạn 1 (Tuần 1 - Tuần 3): Khảo sát tài liệu, cấu hình môi trường hạ tầng Linux, Docker, triển khai Kafka Cluster và MongoDB Container.
  • Giai đoạn 2 (Tuần 4 - Tuần 7): Xây dựng module Producer trích xuất video frame từ Webcam Laptop và Logitech Camera; đóng gói serialized bytes gửi lên Kafka Topics.
  • Giai đoạn 3 (Tuần 8 - Tuần 10): Phát triển Consumer giải mã binary frame, tích hợp pipeline AI xử lý ảnh (Haar Cascades / HOG-SVM / CNN), trích xuất bounding boxes và tính toán mật độ người.
  • Giai đoạn 4 (Tuần 11 - Tuần 12): Thiết lập kết nối Flask Backend, kênh giao tiếp WebSocket Full-Duplex đẩy dữ liệu biểu đồ Plotly, chạy tải thử nghiệm và tối ưu hóa hệ thống.

Implementation và kết quả

Quy trình phát triển và các thành phần mã nguồn cốt lõi

1. Khởi tạo môi trường cụm Kafka và MongoDB bằng Docker

Hệ thống sử dụng file docker-compose.yml (kế thừa từ kiến trúc single-broker Kafka stack) để đóng gói toàn bộ dependencies:

# Khởi động dịch vụ Apache Zookeeper và Kafka Broker
git clone https://github.com/simplesteph/kafka-stack-docker-compose.git
cd kafka-stack-docker-compose
docker-compose -f zk-single-kafka-single.yml up -d

# Khởi chạy MongoDB Server độc lập trên Container
docker run --name mongodb -d -p 27017:27017 -v mongo_data:/data/db mongo:latest

2. Cấu hình Kafka Topics đa phân vùng (Partitions)

Để tối ưu hóa năng lực đọc/ghi đa luồng, hệ thống thiết lập 2 topic độc lập: camera_laptop1 và camera_logitech1, mỗi topic cấu hình 3 Partitions và Replication Factor = 1:

# Lệnh tạo Topic cho luồng Camera Laptop với 3 Partitions
kafka-topics.sh --create --bootstrap-server localhost:9092 \
  --replication-factor 1 --partitions 3 --topic camera_laptop1

# Lệnh tạo Topic cho luồng Camera Logitech
kafka-topics.sh --create --bootstrap-server localhost:9092 \
  --replication-factor 1 --partitions 3 --topic camera_logitech1

3. Module Kafka Producer trích xuất và phát luồng Video

Producer đọc trực tiếp các frames từ thiết bị phần cứng qua OpenCV, mã hóa nén ảnh sang định dạng JPEG và gửi liên tục lên Kafka Broker:

import cv2
import time
from kafka import KafkaProducer

def video_stream_producer(camera_index, topic_name, broker_address='localhost:9092'):
    producer = KafkaProducer(
        bootstrap_servers=[broker_address],
        value_serializer=lambda m: m
    )
    cap = cv2.VideoCapture(camera_index)
    cap.set(cv2.CAP_PROP_FRAME_WIDTH, 640)
    cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 480)
    
    print(f"[*] Started streaming from Camera {camera_index} to Topic: {topic_name}")
    try:
        while cap.isOpened():
            ret, frame = cap.read()
            if not ret:
                break
            
            # Encode frame sang định dạng JPG dạng byte buffer
            _, buffer = cv2.imencode('.jpg', frame, [cv2.IMWRITE_JPEG_QUALITY, 80])
            producer.send(topic_name, buffer.tobytes())
            time.sleep(0.033)  # Đảm bảo tốc độ ~30 FPS
    finally:
        cap.release()
        producer.close()

4. Module Kafka Consumer, Phân tích AI và Lưu trữ

Consumer lắng nghe message từ topic, giải mã binary buffer thành ảnh ma trận (NumPy array), thực hiện nhận diện khuôn mặt, ghi metadata vào MongoDB và phát tín hiệu qua WebSocket:

import cv2
import numpy as np
from kafka import KafkaConsumer
from pymongo import MongoClient
import datetime

# Khởi tạo kết nối MongoDB
mongo_client = MongoClient('mongodb://localhost:27017/')
db = mongo_client['surveillance_db']
collection = db['camera_detections']

# Tải mô hình Face Detection tiền huấn luyện (Haar Cascade / Deep Learning Model)
face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')

def process_stream(topic_name):
    consumer = KafkaConsumer(
        topic_name,
        bootstrap_servers=['localhost:9092'],
        auto_offset_reset='latest',
        enable_auto_commit=True
    )
    
    for message in consumer:
        # Decode byte message thành khung ảnh OpenCV
        nparr = np.frombuffer(message.value, np.uint8)
        frame = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
        
        # Tiền xử lý chuyển ảnh xám
        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
        faces = face_cascade.detectMultiScale(gray, scaleFactor=1.1, minNeighbors=5, minSize=(30, 30))
        person_count = len(faces)
        
        # Lưu hình ảnh nếu phát hiện có đối tượng người
        if person_count > 0:
            timestamp_str = datetime.datetime.now().strftime("%Y%m%d_%H%M%S_%f")
            file_path = f"saved_frames/{topic_name}_{timestamp_str}.jpg"
            cv2.imwrite(file_path, frame)
            
            # Ghi Log Metadata vào MongoDB
            record = {
                "camera_id": topic_name,
                "timestamp": datetime.datetime.utcnow(),
                "person_count": person_count,
                "image_path": file_path
            }
            collection.insert_one(record)

Đánh giá kiểm thử và Thực nghiệm

Benchmark hiệu năng xử lý và độ trễ hệ thống

Chỉ số kiểm thử Camera Laptop (Internal) Camera Logitech (USB 2.0) Hệ thống 2 luồng đồng thời
Độ phân giải (Resolution) 640 x 480 px 1280 x 720 px (downscaled 640x480) $2 \times (640 \times 480\text{ px})$
Tốc độ khung hình (FPS) 28.5 FPS 29.2 FPS 57.4 FPS (tổng xử lý)
Độ trễ trung bình (End-to-End Latency) 82 ms 95 ms 110 ms
Mức chiếm dụng CPU (Intel Core i5/i7) 14.5% 16.2% 33.8%
Dung lượng RAM Container Kafka + Mongo ~480 MB ~495 MB ~620 MB
Tỷ lệ Drop Frame khi tải liên tục 0.02% 0.04% < 0.05% 
+-----------------------------------------------------------------------------+
|                     ĐỘ CHÍNH XÁC NHẬN DIỆN KHUÔN MẶT                        |
+-----------------------------------------------------------------------------+
| Điều kiện ánh sáng đầy đủ (Phòng Lab)  :  Độ chính xác 95.8% (Precision)    |
| Điều kiện góc nghiêng mặt (> 45 độ)    :  Độ chính xác 78.4% (Precision)    |
| Điều kiện ngược sáng / Ánh sáng yếu   :  Độ chính xác 72.1% (Precision)    |
| Tốc độ suy luận AI trung bình / Frame   :  ~ 18.5 ms (CPU Inference)        |
+-----------------------------------------------------------------------------+

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

  1. Phân tách hoàn toàn giữa Thu nhận Video và Xử lý AI: Bằng việc ứng dụng Apache Kafka làm lớp đệm trung gian (Decoupling Ingestion & Processing), hệ thống loại bỏ triệt để hiện tượng "nghẽn cổ chai" thường gặp ở các ứng dụng giám sát OpenCV truyền thống. Khi tải suy luận của mô hình AI tăng đột biến, khung hình được xếp hàng an toàn tại các Kafka Partitions mà không gây crash tiến trình camera.
  2. Kiến trúc mở rộng hướng luồng (Partitioned Scalability): Việc cấu hình 3 partitions cho mỗi topic cho phép dễ dàng mở rộng tăng số lượng AI Consumers chạy song song (Consumer Group) mà không cần viết lại mã nguồn Producer.
  3. Giám sát thời gian thực tương tác cao (Interactive Real-time Visualisation): Sự kết hợp giữa WebSocket và Plotly.js giải quyết bài toán biểu diễn dữ liệu chuỗi thời gian (Time-series) tức thời. Người dùng có thể zoom, pan, tra cứu mật độ người tại từng mốc thời gian cụ thể mà không làm gián đoạn luồng video đang xem.
  4. Hiệu quả lưu trữ dữ liệu thông minh: Chỉ thực hiện lưu ảnh vật lý và metadata lên MongoDB khi phát hiện có người xuất hiện, giúp tiết kiệm hơn 68% dung lượng ổ đĩa so với phương thức ghi hình liên tục (Continuous Video Recording).

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

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

  • Tòa nhà văn phòng và Trường học thông minh: Tự động đếm lưu lượng sinh viên, nhân viên ra vào các sảnh chính, phát hiện người xuất hiện trong các phòng chức năng ngoài giờ quy định.
  • Quản lý bán lẻ (Retail Analytics): Đo lường mật độ khách hàng theo khung giờ, phân tích hiệu quả các gian hàng dựa trên biểu đồ biến thiên số người.
  • Kiểm soát khu vực cách ly / An ninh nghiêm ngặt: Cảnh báo tức thì khi phát hiện có người xâm nhập vào vùng cấm giám sát.

Hướng dẫn triển khai (Deployment Guide)

  1. Yêu cầu phần cứng tối thiểu: CPU Quad-core 2.5GHz+, RAM 8GB+, Ổ cứng 50GB SSD trống, 02 cổng USB 2.0/3.0 hoặc Camera có sẵn.
  2. Cài đặt môi trường: 
    # 1. Cài đặt Docker & Docker Compose trên Ubuntu
sudo apt update && sudo apt install -y docker.io docker-compose

# 2. Khởi chạy Kafka Cluster và MongoDB Database
docker-compose -f zk-single-kafka-single.yml up -d
docker run --name mongodb -d -p 27017:27017 mongo

# 3. Chạy ứng dụng Flask Web Dashboard
python3 app.py

# 4. Kích hoạt Producers đọc luồng camera
python3 producer_laptop.py &
python3 producer_logitech.py &

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

Hạn chế kỹ thuật hiện tại

  • Môi trường phần cứng: Thử nghiệm giới hạn trên phần cứng máy tính cá nhân sử dụng CPU để chạy suy luận mô hình AI, chưa tận dụng phần cứng chuyên dụng (NVIDIA GPU / CUDA Cores / TensorRT).
  • Thuật toán thị giác: Mô hình phát hiện khuôn mặt cơ bản dễ bị ảnh hưởng bởi góc quay khuất, ánh sáng yếu hoặc đối tượng đeo khẩu trang che kín mặt.

Định hướng nâng cấp tương lai

  • Tích hợp mô hình AI tiên tiến: Nâng cấp lên các mạng nơ-ron học sâu hiện đại như YOLOv8 / YOLOv9 kết hợp thuật toán ByteTrack / DeepSORT để theo dõi và định danh hành trình di chuyển của từng đối tượng độc lập.
  • Điện toán biên (Edge Computing): Đóng gói hệ thống chạy trên các vi mạch nhúng như NVIDIA Jetson Nano / Jetson Orin để giảm tải hoàn toàn cho máy chủ trung tâm.
  • Xử lý luồng nâng cao với Kafka Streams & KSQL: Thực hiện tổng hợp cửa sổ thời gian (Tumbling/Hopping Windows) để cảnh báo mật độ đông người tự động trực tiếp trên Kafka broker.

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

+-----------------------------------------------------------------------------+
|                          ĐỐI TƯỢNG HƯỞNG LỢI                                |
+-----------------------------------------------------------------------------+
| Sinh viên CNTT / IoT:  Nguồn tài liệu tham khảo hoàn chỉnh về cách tích     |
|                        hợp Event-Streaming (Kafka) vào bài toán Computer     |
|                        Vision thực tế.                                      |
|                                                                             |
| Kỹ sư phần mềm:        Pattern kiến trúc chuẩn Microservices xử lý dữ liệu  |
|                        nhị phân (Video frames) tải cao, không nghẽn luồng.  |
|                                                                             |
| Doanh nghiệp / Tổ chức:Giải pháp giám sát chi phí thấp, tận dụng hạ tầng    |
|                        camera có sẵn, tiết kiệm 60-70% băng thông lưu trữ.  |
+-----------------------------------------------------------------------------+

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

1. Yêu cầu kỹ thuật tối thiểu để 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+), tối thiểu 8GB RAM để vận hành trơn tru cả Zookeeper, Kafka Broker, MongoDB và ứng dụng Flask. Thiết bị cần hỗ trợ tối thiểu 2 cổng kết nối camera USB hoặc camera RTSP IP trong cùng dải mạng nội bộ.

2. Làm thế nào để mở rộng hệ thống lên 10 hoặc 20 camera cùng lúc?

Để mở rộng hệ thống, ta áp dụng cơ chế Scale Horizontal:

  • Tăng số lượng Brokers trong Kafka Cluster.
  • Mỗi camera tạo 1 Topic riêng biệt với từ 3 đến 5 Partitions.
  • Triển khai nhóm Consumer Group chạy trên các máy worker riêng biệt (hoặc cụm Kubernetes Pods) có GPU để chia tải giải mã và chạy suy luận AI song song.

3. Tại sao lại chọn Apache Kafka thay vì Redis Queue hay RabbitMQ cho video streaming?

Apache Kafka được thiết kế chuyên biệt cho thông lượng cực lớn (High Throughput) với cơ chế lưu trữ phân vùng tuần tự trên đĩa cứng (Sequential Disk I/O). Khác với RabbitMQ hoặc Redis lưu message trên bộ nhớ RAM (dễ cạn kiệt khi dữ liệu video byte quá lớn), Kafka duy trì hiệu năng ổn định hàng trăm MB/giây và cho phép nhiều Consumer groups cùng đọc lại dữ liệu theo offset độc lập.

4. Cơ sở dữ liệu MongoDB có bị chậm khi lưu hàng triệu sự kiện nhận diện không?

MongoDB hỗ trợ rất mạnh cho dữ liệu phi cấu trúc và sharding mở rộng ngang. Bằng việc đánh chỉ mục (Index) trên các trường truy vấn thường xuyên như camera_id và timestamp (B-Tree Indexing hoặc Compound Index), thời gian truy vấn lịch sử luôn duy trì dưới $10\text{ ms}$ ngay cả khi collection đạt hàng triệu documents.

5. Chi phí triển khai và thời gian hoàn vốn (ROI) ước tính như thế nào?

Hệ thống sử dụng 100% các công nghệ nguồn mở miễn phí (Ubuntu, Python, Kafka, MongoDB Community, Docker). Doanh nghiệp chỉ cần đầu tư chi phí phần cứng ban đầu. So với việc mua bản quyền các phần mềm VMS (Video Management Software) thương mại đắt đỏ, giải pháp này giúp tiết kiệm từ 65% - 80% chi phí đầu tư ban đầu, mang lại điểm hòa vốn chỉ trong vòng 6 - 9 tháng vận hành.

Kết luận

Đồ án tốt nghiệp "Xây dựng hệ thống xử lý đa luồng kết hợp với AI cho hệ thống camera giám sát thông minh" của sinh viên Vũ Đức Duy đã giải quyết trọn vẹn và bài bản bài toán kỹ thuật từ lý thuyết đến thực nghiệm. Bằng việc kết hợp nhuần nhuyễn giữa nền tảng streaming phân tán Apache Kafka, cơ sở dữ liệu MongoDB NoSQL, công nghệ ảo hóa Docker và các thuật toán Thị giác máy tính AI, đề tài đã xây dựng thành công một giải pháp giám sát an ninh đa luồng có tính ứng dụng thực tiễn cao, hiệu năng vượt trội và khả năng mở rộng linh hoạt.

Hệ thống không chỉ đóng vai trò là một minh chứng xuất sắc cho năng lực nghiên cứu ứng dụng công nghệ của sinh viên ngành Công nghệ Thông tin Phenikaa, mà còn mở ra nền móng vững chắc cho các hệ sinh thái camera thông minh trong các dự án thành phố thông minh (Smart City) và nhà máy tự động hóa trong tương lai.