Giới thiệu dự án

Hỏa hoạn và cháy rừng là thảm họa tự nhiên và nhân tạo nghiêm trọng, gây thiệt hại nặng nề về hệ sinh thái, cơ sở hạ tầng kinh tế và tính mạng con người. Theo thống kê từ Cục Cảnh sát Phòng cháy chữa cháy và Cứu nạn cứu hộ cùng Tổng cục Lâm nghiệp, Việt Nam sở hữu hơn 14,7 triệu hecta rừng với địa hình đồi núi hiểm trở, khiến công tác tuần tra cảnh báo 24/7 của lực lượng kiểm lâm gặp áp lực cực lớn về nhân lực và phạm vi kiểm soát.

Vấn đề cốt lõi của các giải pháp báo cháy truyền thống:

  • Cảm biến vật lý (khói, nhiệt, CO): Chỉ phản ứng khi nồng độ khói hoặc nhiệt độ cục bộ đạt ngưỡng kích hoạt, cự ly hiệu dụng ngắn (<10m), hoàn toàn bất khả thi đối với không gian mở ngoài trời, nhà xưởng trần cao hoặc diện tích rừng rộng lớn.
  • Camera nhiệt hồng ngoại (Thermal Camera): Chi phí đầu tư phần cứng đắt đỏ ($1,500 - $5,000/node), chi phí bảo dưỡng cao, khó triển khai đại trà ở quy mô biên mạng (Edge computing).

Đồ án khóa luận "Hệ thống cảnh báo cháy sử dụng camera ứng dụng trí tuệ nhân tạo (AI-Based Camera for Fire Detection)" do sinh viên Hồng Chan Hiển thực hiện dưới sự hướng dẫn của TS. Lê Kim Hùng tại Trường Đại học Công nghệ Thông tin - ĐHQG TP.HCM (Khoa Mạng máy tính và Truyền thông, Ngành An toàn Thông tin) giải quyết triệt để bài toán trên bằng cách kết hợp Deep Learning với phần cứng nhúng chi phí thấp.

flowchart LR
    A[Raspberry Pi Camera V2] -->|MIPI CSI Video Stream| B[Edge Node: Raspberry Pi 4]
    B -->|OpenCV Frame Preprocessing 224x224| C[TensorFlow Lite Engine: FireNet Lite]
    C -->|HTTP POST Telemetry & Alarm| D[ThingsBoard IoT Server]
    D -->|HTTPS TLS 1.3| E[Web Dashboard / User Interface]
    B -->|MJPEG Live Stream Port 5000| E

Mục tiêu dự án

  1. Nghiên cứu và tối ưu hóa kiến trúc AI: Tái cấu trúc mô hình FireNet và thử nghiệm Vision Transformer (ViT) trên nền tảng TensorFlow 2.x, tối ưu hóa suy luận (inference) bằng kỹ thuật Weight Pruning và Quantization.
  2. Triển khai Edge Computing: Đóng gói và thực thi mô hình nhúng trên máy tính đơn bo (SBC) Raspberry Pi 4 sử dụng TensorFlow Lite đa luồng (num_threads=4), tối ưu hóa tải CPU/GPU và kiểm soát hiện tượng nghẽn nhiệt (thermal throttling).
  3. Xây dựng hệ thống IoT hoàn chỉnh: Phát triển kiến trúc Client-Server tích hợp nền tảng quản trị ThingsBoard, xử lý luồng cảnh báo qua Rule Engine, phát video trực tiếp qua Flask Server và mã hóa đường truyền bằng HTTPS/TLS.

Kết quả kỳ vọng và chỉ số đo lường

  • Độ chính xác phân loại (Validation Accuracy): Đạt trên 95% trên tập dữ liệu chuẩn hóa 38,522 ảnh.
  • Tỷ lệ nén mô hình (Compression Ratio): Giảm kích thước tệp trọng số từ 494 MB xuống dưới 45 MB (giảm >90%).
  • Thời gian phản hồi cảnh báo: Độ trễ phát hiện cháy và kích hoạt báo động trên server dưới 2 giây.

Phạm vi và giới hạn

  • Hệ thống tập trung vào tác vụ phát hiện ngọn lửa (Fire Classification) thời gian thực trong tầm nhìn camera quan sát (Camera FOV).
  • Thử nghiệm trên mạng cục bộ (LAN) và kết nối mạng diện rộng bảo mật qua giao thức HTTP/HTTPS.

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

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

Tiêu chí Cảm biến khói/nhiệt truyền thống Camera nhiệt hồng ngoại Hệ thống Camera AI đề xuất (FireNet Lite)
Phạm vi giám sát Rất hẹp (bán kính < 5-10m) Rộng (lên đến hàng trăm mét) Rộng (toàn bộ góc nhìn quang học camera)
Môi trường hoạt động Chỉ hiệu quả trong phòng kín Trong nhà và ngoài trời Trong nhà, nhà xưởng, khuôn viên, rừng
Thời gian phát hiện Chậm (chờ khói/nhiệt tích tụ) Rất nhanh (phát hiện bức xạ nhiệt) Ngay khi ngọn lửa xuất hiện trong khung hình (<1s)
Cảnh báo giả Dễ nhiễu bởi bụi, côn trùng, hơi nước Nhiễu do nguồn nhiệt công nghiệp Khắc phục nhờ tập dữ liệu huấn luyện đa dạng
Chi phí phần cứng Thấp ($10 - $30/điểm) Rất cao ($1,000 - $5,000/node) Tối ưu ($80 - $120/trạm bao gồm Pi + Cam)

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

  • Must have: Tự động nhận diện lửa từ luồng video camera; nén mô hình AI chạy trực tiếp trên Raspberry Pi 4; gửi cảnh báo tức thì về Server khi phát hiện cháy; giao diện Dashboard hiển thị trạng thái và cảnh báo.
  • Should have: Luồng video trực tiếp (Live Stream) tích hợp trên Dashboard; bảo mật truyền thông qua giao thức HTTPS; cơ chế xử lý logic cảnh báo qua Rule Chain.
  • Could have: Hỗ trợ mở rộng trên phần cứng tăng tốc chuyên dụng (NVIDIA Jetson Nano với TensorRT, Google Coral Edge TPU).
  • Won't have (giai đoạn này): Phân vùng bounding-box chính xác tọa độ pixel (Instance Segmentation) do giới hạn tài nguyên CPU trên Raspberry Pi 4.

Thiết kế hệ thống

Kiến trúc phân tầng của hệ thống gồm hai thành phần vật lý độc lập:

  1. Edge Client Node (Raspberry Pi 4 - 2GB RAM):

    • Module Camera Raspberry Pi V2 (cảm biến Sony IMX219 8MP) kết nối qua giao diện phần cứng MIPI CSI.
    • Module tiền xử lý khung hình OpenCV: Capture frame, resize chuẩn $224 \times 224$, chuyển đổi không gian màu RGB sang BGR.
    • Trình thông dịch TensorFlow Lite: Nạp mô hình quant_pruned_firenet.tflite, phân bổ tensor và thực thi suy luận đa luồng.
    • Flask Micro-Web Server: Khởi tạo tiến trình daemon phục vụ giao diện phát video stream dạng MJPEG qua cổng 5000.
    • Telemetry Sender: Sử dụng thư viện requests đẩy bản tin JSON chứa kết quả phân loại lên Server qua HTTP POST API.

  2. Management Server Node (Raspberry Pi 4 / Linux Server):

    • Nền tảng IoT ThingsBoard Community Edition (v3.x).
    • Cơ sở dữ liệu lai: PostgreSQL lưu trữ cấu hình thiết bị, người dùng, metadata; Cassandra lưu trữ chuỗi thời gian telemetry.
    • Root Rule Chain Engine: Tiếp nhận payload, parse thuộc tính JSON, kích hoạt chuỗi sự kiện tạo cảnh báo (Create Alarm), gửi cảnh báo âm thanh/giao diện người dùng.
    • Web Server Reverse Proxy: Apache2 cấu hình OpenSSL, mã hóa luồng HTTP sang HTTPS (Port 443).
Payload gửi từ Edge Client lên ThingsBoard Server (POST /api/v1/{ACCESS_TOKEN}/telemetry):
{
  "fire_detected": true,
  "confidence": 0.9624,
  "inference_time_ms": 142.5,
  "device_temperature": 54.2
}

graph TD
    subgraph Edge_Client [Edge Client Node - Raspberry Pi 4]
        Cam[Raspberry Pi Camera V2] -->|Raw Video| OCV[OpenCV Frame Capture]
        OCV -->|224x224 BGR Frame| TFL[TFLite Interpreter FireNet Lite]
        OCV -->|MJPEG Stream| FLS[Flask Video Server :5000]
        TFL -->|Inference Result| POS[HTTP Telemetry Client]
    end

    subgraph Core_Server [ThingsBoard Server Node]
        POS -->|POST Telemetry| RCE[ThingsBoard Rule Engine]
        RCE -->|Process JSON| DB[(PostgreSQL / Cassandra)]
        RCE -->|Trigger Event| ALM[Alarm Controller]
        ALM -->|Push State| DSH[ThingsBoard Dashboard]
    end

    subgraph Security_Layer [Reverse Proxy]
        DSH -->|Internal HTTP| APC[Apache2 SSL / TLS 1.3 Engine]
        APC -->|Secure HTTPS 443| USR[Operator Browser Client]
        FLS -->|Live Feed| USR
    end

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

Dự án áp dụng quy trình phát triển lặp (Iterative Engineering Methodology):

  • Giai đoạn 1 (Thu thập và tiền xử lý dữ liệu): Khai thác tập dữ liệu Durham Fire Detection Dataset với 38,522 ảnh ($224 \times 224$ pixels), chuẩn hóa và phân chia tỷ lệ 80% Training (30,818 ảnh) và 20% Validation (7,704 ảnh).
  • Giai đoạn 2 (Xây dựng và huấn luyện mô hình): Thiết kế mô hình FireNet trên Keras/TensorFlow 2, thử nghiệm đối chứng với mô hình Vision Transformer (ViT).
  • Giai đoạn 3 (Tối ưu hóa mô hình): Ứng dụng kỹ thuật Pruning (tỉa trọng số) và Dynamic Range Quantization để chuyển đổi sang định dạng TFLite.
  • Giai đoạn 4 (Tích hợp hệ thống và kiểm thử thực địa): Lập trình dịch vụ client nhúng, kết nối hệ thống phân tán ThingsBoard và đánh giá hiệu năng chịu tải.

Implementation và kết quả

Quá trình phát triển và thuật toán cốt lõi

Kiến trúc FireNet Lite được thiết kế dưới dạng mạng tích chập tuần tự (Sequential CNN), khắc phục các hạn chế của phiên bản TensorFlow 1 cũ bằng việc thay thế lớp LocalResponseNormalization bằng BatchNormalization, tăng cường khả năng hội tụ và tính ổn định gradient.

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Conv2D, MaxPooling2D, BatchNormalization, Flatten, Dense, Dropout

def build_firenet_lite(input_shape=(224, 224, 3)):
    model = Sequential([
        # Block 1: Trích xuất đặc trưng biên và góc ngọn lửa
        Conv2D(64, kernel_size=(5, 5), strides=(4, 4), activation='relu', input_shape=input_shape),
        MaxPooling2D(pool_size=(3, 3), strides=(2, 2)),
        BatchNormalization(),
        
        # Block 2: Trích xuất đặc trưng màu sắc và khối lửa
        Conv2D(128, kernel_size=(4, 4), strides=(1, 1), activation='relu'),
        MaxPooling2D(pool_size=(3, 3), strides=(2, 2)),
        BatchNormalization(),
        
        # Block 3: Trích xuất đặc trưng ngữ cảnh phức tạp
        Conv2D(256, kernel_size=(1, 1), strides=(1, 1), activation='relu'),
        MaxPooling2D(pool_size=(3, 3), strides=(2, 2)),
        
        # Flatten và Phân loại (Classification)
        Flatten(),
        BatchNormalization(),
        Dense(4096, activation='tanh'),
        Dropout(0.5),
        Dense(4096, activation='tanh'),
        Dropout(0.5),
        Dense(2, activation='softmax')
    ])
    return model

Tối ưu hóa mô hình qua Weight Pruning và Dynamic Range Quantization

Kỹ thuật Pruning sử dụng lịch trình PolynomialDecay loại bỏ các liên kết trọng số có độ lớn nhỏ về giá trị 0, nâng độ thưa (sparsity) từ 50% lên 80% trong 50 epochs huấn luyện. Tiếp đó, Dynamic Range Quantization lượng tử hóa các trọng số tĩnh từ kiểu 32-bit Floating Point (float32) sang 8-bit Integer (int8), trong khi vẫn duy trì tính toán kích hoạt thời gian chạy ở mức dấu phẩy động để bảo toàn độ chính xác.

import tensorflow_model_optimization as tfmot

# 1. Cấu hình và huấn luyện Pruning
pruning_params = {
    'pruning_schedule': tfmot.sparsity.keras.PolynomialDecay(
        initial_sparsity=0.50,
        final_sparsity=0.80,
        begin_step=0,
        end_step=1000
    )
}
model_for_pruning = tfmot.sparsity.keras.prune_low_magnitude(model, **pruning_params)
model_for_pruning.compile(
    optimizer=tf.keras.optimizers.Adam(learning_rate=1e-4),
    loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False),
    metrics=['accuracy']
)

# 2. Xuất mô hình và Lượng tử hóa sang TFLite
model_for_export = tfmot.sparsity.keras.strip_pruning(model_for_pruning)
converter = tf.lite.TFLiteConverter.from_keras_model(model_for_export)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
quantized_pruned_tflite = converter.convert()

with open("quant_pruned_firenet.tflite", "wb") as f:
    f.write(quantized_pruned_tflite)

Mã thực thi suy luận nhúng trên Raspberry Pi Client

import cv2
import numpy as np
import tensorflow as tf
import requests
import json
import time

# Khởi tạo TFLite Interpreter với 4 luồng CPU
interpreter = tf.lite.Interpreter(model_path="quant_pruned_firenet.tflite", num_threads=4)
interpreter.allocate_tensors()
input_details = interpreter.get_input_details()
output_details = interpreter.get_output_details()

THINGSBOARD_HOST = "http://192.168.1.100:8080"
ACCESS_TOKEN = "PI4_FIRE_DETECTION_NODE_01"
TELEMETRY_URL = f"{THINGSBOARD_HOST}/api/v1/{ACCESS_TOKEN}/telemetry"

cap = cv2.VideoCapture(0)

while cap.isOpened():
    ret, frame = cap.read()
    if not ret:
        break
        
    start_time = time.time()
    # Tiền xử lý: Resize về 224x224 và chuẩn hóa tensor
    resized = cv2.resize(frame, (224, 224))
    input_data = np.expand_dims(resized, axis=0).astype(np.float32)
    
    interpreter.set_tensor(input_details[0]['index'], input_data)
    interpreter.invoke()
    output_data = interpreter.get_tensor(output_details[0]['index'])
    
    fire_prob = float(output_data[0][0])
    nofire_prob = float(output_data[0][1])
    is_fire = fire_prob > 0.65  # Ngưỡng kích hoạt cảnh báo
    inference_time = (time.time() - start_time) * 1000
    
    payload = {
        "fire_detected": is_fire,
        "fire_confidence": round(fire_prob, 4),
        "inference_ms": round(inference_time, 2)
    }
    
    try:
        requests.post(TELEMETRY_URL, data=json.dumps(payload), headers={'Content-Type': 'application/json'}, timeout=0.5)
    except Exception as e:
        print(f"Network error: {e}")

Thử nghiệm và đánh giá thực nghiệm

Hệ thống được đánh giá qua 1,500 mẫu thử nghiệm độc lập trong nhiều điều kiện môi trường: ánh sáng mạnh ngoài trời, ánh sáng yếu ban đêm, khói nhân tạo, vật cản và nguồn sáng giả định (đèn halogen, ánh hoàng hôn).

Kiến trúc mô hình Số lượng tham số (Parameters) Kích thước tệp lưu trữ Training Accuracy Validation Accuracy Tốc độ suy luận (RPi 4 CPU) Tốc độ suy luận (Jetson Nano)
FireNet gốc (TF 1.x) 43,190,275 494 MB (.h5) 92.4% 92.0% 2.0 FPS (~500ms) 20.0 FPS (~50ms)
Vision Transformer (ViT) 22,842,114 44.6 MB (.tflite FP16) 98.1% 97.5% 0.8 FPS (~1250ms) 12.5 FPS (~80ms)
FireNet Lite (Đề xuất) 43,190,275 (Sparse) 41.2 MB (.tflite) 96.01% 96.2% 7.5 FPS (~133ms) 32.0 FPS (~31ms) 
Phân tích ma trận nhầm lẫn (Confusion Matrix trên 7,704 ảnh tập Validation):
- True Positive (Phát hiện đúng có lửa): 3,745 ảnh (Tỷ lệ: 96.3%)
- True Negative (Xác nhận đúng không lửa): 3,666 ảnh (Tỷ lệ: 96.1%)
- False Positive (Báo động giả): 148 ảnh (Tỷ lệ: 3.9%)
- False Negative (Bỏ sót đám cháy): 145 ảnh (Tỷ lệ: 3.7%)

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

  1. Tối ưu hóa thành công mạng Deep CNN cho kiến trúc vi xử lý ARM: Thiết kế quy trình nén mô hình hai giai đoạn (Pruning Decay + Dynamic Quantization), giảm dung lượng FireNet từ 494 MB xuống 41.2 MB (giảm 91.66% dung lượng lưu trữ), đưa tốc độ thực thi trên CPU Raspberry Pi 4 từ 2 FPS lên 7.5 FPS (tăng tốc độ gấp 3.75 lần) mà không làm suy giảm độ chính xác nhận diện ($96.2% > 92.0%$).
  2. Khảo sát và chuyển đổi thành công kiến trúc Vision Transformer (ViT) sang TFLite FP16: Đạt độ chính xác cao nhất ($97.5%$), chứng minh tính khả thi của việc đưa cơ chế Self-Attention lên thiết bị nhúng.
  3. Hiện thực hóa kiến trúc Edge AI kết hợp IoT hoàn chỉnh: Triển khai giải pháp phân tán giữa Edge Node và IoT Hub (ThingsBoard), loại bỏ sự phụ thuộc vào các dịch vụ Cloud AI đắt tiền, đảm bảo quyền riêng tư dữ liệu và khả năng tự chủ vận hành khi mất kết nối mạng ngoài.

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

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

  • Trạm quan sát kiểm lâm phòng chống cháy rừng: Lắp đặt tại các chòi quan sát cao độ, kết nối camera góc rộng để quét bán kính rừng tự nhiên.
  • Nhà xưởng sản xuất, kho bãi vật liệu dễ cháy: Giám sát các khu vực chứa dung môi hữu cơ, gỗ, bao bì nơi cảm biến khói bị vô hiệu hóa do thông gió lớn.
  • Tòa nhà chung cư và bãi đỗ xe ngầm: Tích hợp vào hệ thống CCTV sẵn có để tăng lớp bảo vệ chủ động.
graph LR
    subgraph Tram_Bien [Trạm quan sát Edge ngoài thực địa]
        P1[Tấm pin mặt trời 50W + Ắc quy 12V] --> P2[Mạch hạ áp LM2596 5V-3A]
        P2 --> P3[Raspberry Pi 4 + Vỏ tản nhiệt nhôm + Quạt]
        Cam1[Camera góc rộng 120 độ] --> P3
    end

    subgraph Truyền_Dẫn [Truyền thông]
        P3 -->|Module 4G LTE / Wi-Fi Mesh| GW[Gateway Mạng]
    end

    subgraph Trung_Tâm [Trung tâm điều hành]
        GW -->|HTTPS / MQTT| SRV[ThingsBoard Server]
        SRV -->|Kích hoạt| SPK[Còi hú & Hệ thống chữa cháy tự động]
        SRV -->|Thông báo| SMS[Telegram / SMS cảnh báo quản lý]
    end

Ước tính chi phí và hiệu quả đầu tư (ROI Analysis)

Hạng mục thiết bị cho 01 trạm Edge Đơn giá ước tính (VND) Tỷ trọng
Bo mạch Raspberry Pi 4 Model B (2GB RAM) 1,350,000 52%
Module Raspberry Pi Camera V2 (8MP Sony Sensor) 650,000 25%
Thẻ nhớ MicroSD 32GB SanDisk Industrial Class 10 200,000 8%
Bộ nguồn 5V-3A chính hãng + Vỏ hợp kim tản nhiệt 250,000 10%
Chi phí vật tư lắp đặt, jack cắm 150,000 5%
Tổng chi phí 01 trạm giám sát thông minh 2,600,000 VND (~$110) 100%

So sánh hiệu quả: Chi phí triển khai 10 trạm giám sát Edge AI chỉ tương đương khoảng 26 triệu VND, thấp hơn 80% so với việc lắp đặt 01 camera nhiệt hồng ngoại chuyên dụng ($3,000 \approx 70\text{ triệu VND}$), nhưng mở rộng được 10 góc quan sát độc lập phân tán.

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

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

  • Nghẽn cổ chai CPU khi suy luận: Xử lý luồng video liên tục khiến CPU Raspberry Pi 4 duy trì mức tải 85-95%, làm nhiệt độ chip vượt $65^\circ\text{C}$ nếu thiếu giải pháp tản nhiệt chủ động.
  • Hạn chế về dữ liệu cảnh báo khói: Mô hình hiện tại tập trung phân loại ngọn lửa sáng, chưa nhận diện hiệu quả các vụ cháy âm ỉ tạo nhiều khói đặc ban ngày.

Hướng phát triển tiếp theo

  • Tích hợp phần cứng TensorRT & Edge TPU: Chuyển đổi mô hình sang định dạng Full Integer Quantization (INT8) để chạy trực tiếp trên thanh tăng tốc Google Coral USB Accelerator hoặc bo mạch NVIDIA Jetson Nano, nâng tốc độ xử lý lên trên 30 FPS.
  • Nâng cấp mô hình phát hiện vị trí (Object Detection): Triển khai các biến thể thu nhỏ YOLOv5-Nano hoặc MobileNetV3-SSD nhằm trả về tọa độ Bounding Box của ngọn lửa trong khung hình.
  • Tích hợp cảnh báo đa kênh: Bổ sung Webhook thông báo tự động qua ứng dụng Telegram Bot, gửi tin nhắn SMS khẩn cấp tới đội phản ứng nhanh.

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

  • Sinh viên & Nghiên cứu sinh: Cung cấp tài liệu tham khảo chi tiết về quy trình tối ưu hóa mô hình học sâu (Pruning, Quantization) từ lý thuyết đến triển khai thực tế trên vi điều khiển/máy tính nhúng.
  • Kỹ sư nhúng & AI Developers: Nắm vững kỹ thuật lập trình đa luồng tích hợp TFLite, OpenCV và cấu trúc phân tán IoT với ThingsBoard Rule Engine.
  • Doanh nghiệp & Đơn vị PCCC: Sở hữu giải pháp công nghệ giá thành thấp, dễ chế tạo đại trà, độ bền cao để giám sát an toàn cháy nổ tại các cơ sở phân tán.

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

1. Cấu hình phần cứng tối thiểu để triển khai hệ thống là gì?

Ở phía Edge Node, cấu hình tối thiểu là Raspberry Pi 4 (2GB RAM) hoặc Raspberry Pi 3B+ (tốc độ suy luận sẽ giảm còn ~3 FPS), kèm nguồn điện 5V/3A ổn định và quạt tản nhiệt. Phía Server yêu cầu máy chủ hoặc máy ảo Linux chạy Ubuntu 20.04/Debian, 2 Core CPU, 4GB RAM và 20GB ổ cứng để vận hành ThingsBoard và PostgreSQL.

2. Mô hình có gặp tình trạng báo động giả khi gặp bóng đèn, mặt trời hoặc vật thể màu đỏ không?

Nhờ quá trình huấn luyện trên tập dữ liệu đa dạng (18,640 ảnh thuộc lớp nofire bao gồm hoàng hôn, xe cứu hỏa, bóng đèn halogen, phản chiếu kim loại), mô hình học được các đặc trưng phức tạp về kết cấu và cạnh ngọn lửa. Tỷ lệ báo động giả (False Positive) đo đạc thực tế chỉ ở mức 3.9%.

3. Làm thế nào để giải quyết vấn đề tăng nhiệt độ trên Raspberry Pi 4 khi vận hành 24/7?

Cần trang bị vỏ hợp kim nhôm tản nhiệt nguyên khối gắn liền với quạt điều tốc tự động. Về mặt phần mềm, chương trình nhúng có thể thiết lập cơ chế "Adaptive Frame Skipping" (chỉ kích hoạt suy luận AI mỗi 3-5 khung hình một lần nếu không phát hiện biến động chuyển động từ OpenCV Background Subtraction).

4. Hệ thống có thể mở rộng kết nối hàng trăm trạm camera cùng lúc không?

Hoàn toàn khả thi. Do toàn bộ quá trình tính toán AI nặng nhất được xử lý cục bộ tại từng thiết bị Edge (Edge Computing), các trạm chỉ gửi payload telemetry dung lượng rất nhỏ (<1 KB) về ThingsBoard Server. Một máy chủ ThingsBoard tầm trung có thể tiếp nhận và xử lý hàng chục nghìn thiết bị gửi dữ liệu đồng thời.

5. Tại sao đồ án chọn giao thức HTTP POST thay vì MQTT để truyền telemetry?

Giao thức HTTP POST dễ tích hợp với Web API tiêu chuẩn của ThingsBoard, đơn giản hóa kiến trúc mã nguồn client bằng thư viện requests của Python. Tuy nhiên, hệ thống hoàn toàn có thể chuyển đổi sang giao thức MQTT thông qua thư viện paho-mqtt để giảm thêm băng thông mạng và tối ưu hóa năng lượng truyền dẫn.

Kết luận

Khóa luận tốt nghiệp "Hệ thống cảnh báo cháy sử dụng camera ứng dụng trí tuệ nhân tạo" của tác giả Hồng Chan Hiển đã nghiên cứu và phát triển thành công giải pháp giám sát an toàn cháy nổ hiện đại, kết hợp nhuần nhuyễn giữa Trí tuệ nhân tạo biên (Edge AI) và Internet of Things (IoT). Bằng việc tinh chỉnh kiến trúc mạng nơ-ron tích chập FireNet Lite và ứng dụng các kỹ thuật nén mô hình tiên tiến (Pruning và Dynamic Range Quantization), hệ thống đạt độ chính xác 96.2% với tốc độ xử lý 7.5 FPS mượt mà trên phần cứng Raspberry Pi 4 chi phí thấp.

Giải pháp chứng minh tính ứng dụng cao, khả năng triển khai thực tế vượt trội so với các hệ thống cảm biến thụ động hoặc camera tầm nhiệt đắt đỏ, mở ra tiềm năng ứng dụng rộng rãi trong bảo vệ rừng và an toàn công nghiệp tại Việt Nam.