Giới thiệu dự án

Thị giác máy tính (Computer Vision) và học sâu (Deep Learning) đang định hình lại các ngành công nghiệp mũi nhọn, đặc biệt là công nghệ xe tự hành (Autonomous Vehicles) và hệ thống hỗ trợ lái xe nâng cao (ADAS - Advanced Driver Assistance Systems). Theo thống kê từ MarketsandMarkets, thị trường xe tự hành toàn cầu dự kiến đạt quy mô hơn 62 tỷ USD vào năm 2026 với tốc độ tăng trưởng kép (CAGR) vượt 39.5%. Trong hệ sinh thái này, khả năng nhận thức môi trường (Environmental Perception) với độ chính xác ở mức từng điểm ảnh (pixel-level) là yếu tố sống còn để đảm bảo an toàn vận hành thời gian thực.

+-------------------------------------------------------------------------+
|                              ẢNH ĐẦU VÀO                                |
|                        (Urban Scene: 256x256x3)                         |
+-------------------------------------------------------------------------+
                                     |
                                     v
+-------------------------------------------------------------------------+
|                  U-NET ARCHITECTURE (ENCODER - DECODER)                 |
|  [Contracting Path] ---- (Skip Connections) ----> [Expansive Path]      |
|  Conv2D + BatchNorm + ReLU                       Conv2DTranspose + ReLU |
+-------------------------------------------------------------------------+
                                     |
                                     v
+-------------------------------------------------------------------------+
|                         BẢN ĐỒ PHÂN ĐOẠN ĐẦU RA                         |
|             (Gán nhãn ngữ nghĩa từng pixel: Xe, Đường, Người)           |
+-------------------------------------------------------------------------+

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

Các kỹ thuật phân loại hình ảnh (Image Classification) hay phát hiện đối tượng (Object Detection) truyền thống chỉ đóng khung đối tượng qua các hộp bao (Bounding Boxes). Phương pháp này bỏ sót thông tin hình học chi tiết của ranh giới vật thể, dẫn đến sai số nghiêm trọng khi xe tự hành cần xác định chính xác lề đường, làn phân cách, chướng ngại vật phức tạp hoặc người đi bộ trong điều kiện đô thị đông đúc. Phân đoạn ngữ nghĩa (Semantic Segmentation) giải quyết triệt để hạn chế này bằng cách phân loại và gán nhãn ngữ nghĩa cho toàn bộ các pixel trong ảnh.

Mục tiêu dự án

  1. Nghiên cứu lý thuyết: Tổng hợp cơ sở khoa học về mạng nơ-ron tích chập (CNN) và các kiến trúc kinh điển như LeNet-5, AlexNet, VGG-16, GoogLeNet/Inception, và U-Net.
  2. Thiết kế kiến trúc U-Net tối ưu: Xây dựng mô hình phân đoạn ngữ nghĩa dạng Encoder-Decoder với các khối tích chập trích xuất đặc trưng kết hợp cơ chế liên kết tắt (Skip Connections).
  3. Huấn luyện và thực nghiệm: Tiền xử lý tập dữ liệu giao thông thực tế CamVid (Cambridge-driving Labeled Video Database), chuẩn hóa dữ liệu về kích thước $256 \times 256 \times 3$, tối ưu hóa mô hình với thuật toán Adam.
  4. Đánh giá định lượng: Kiểm thử và phân tích hiệu năng mô hình trên tập dữ liệu kiểm tra độc lập, đánh giá độ chính xác phân đoạn và khả năng tổng quát hóa trên ảnh đơn lẻ.

Phương pháp tiếp cận

Dự án áp dụng mô hình U-Net – một kiến trúc mạng nơ-ron tích chập đối xứng chuyên sâu. Mạng kết hợp giữa:

  • Contracting Path (Encoder): Giảm dần độ phân giải không gian qua các tầng Conv2D và MaxPooling để bắt các đặc trưng ngữ nghĩa mức cao (High-level Context).
  • Expansive Path (Decoder): Tăng kích thước không gian thông qua các phép tích chập chuyển vị (Transposed Convolution/Up-sampling).
  • Skip Connections: Nối trực tiếp các bản đồ đặc trưng (Feature Maps) có độ phân giải cao từ nhánh Encoder sang Decoder, bảo toàn thông tin biên cạnh và vị trí không gian bị tiêu hao trong quá trình nén.

Kết quả kỳ vọng và Phạm vi dự án

  • Kết quả đo lường được: Xây dựng thành công pipeline huấn luyện hoàn chỉnh trên nền tảng đám mây Google Colab (T4 GPU), đạt độ chính xác phân loại pixel (Pixel Accuracy) vượt $88%$ trên tập dữ liệu đánh giá, tối ưu hóa kích thước mô hình để duy trì thời gian suy luận nhanh.
  • Phạm vi & Giới hạn: Thử nghiệm tập trung vào kịch bản lái xe đô thị từ tập dữ liệu CamVid với 32 lớp ngữ nghĩa (sau đó gom nhóm và tiền xử lý), huấn luyện ở kích thước ảnh chuẩn $256 \times 256$, chưa triển khai trực tiếp trên phần cứng nhúng biên (Edge AI hardware).

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

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

So sánh các phương pháp phân vùng ảnh

Tiêu chí Phân vùng theo ngưỡng (Thresholding) / Biên (Edge-based) Fully Convolutional Networks (FCN-8s / FCN-16s) U-Net Architecture (Giải pháp lựa chọn)
Bản chất kỹ thuật Dựa trên cường độ sáng ($P(c_1, c_2)$), bộ lọc Sobel/Canny, Watershed Thay thế Fully Connected bằng Conv 1x1, khử tích chập để tái tạo kích thước Kiến trúc mạng nơ-ron đối xứng Encoder-Decoder kèm Skip Connections đa tầng
Độ chính xác ngữ nghĩa Thấp; dễ vỡ vùng khi độ tương phản thay đổi hoặc có nhiễu Trung bình - Khá ($70% - 80%$ mIoU); chi tiết ranh giới còn mờ Rất cao ($>85%$); bắt trọn ranh giới nhờ ghép nối trực tiếp đặc trưng biên
Số lượng tham số Không có tham số học sâu ($0$ params) Lớn (khoảng 134 triệu tham số dựa trên backbone VGG-16) Tối ưu hóa linh hoạt (khoảng 1.8M - 7.8M tham số tùy bộ lọc gốc)
Tài nguyên tính toán Thấp, chạy trên CPU chuẩn Yêu cầu bộ nhớ GPU lớn; suy luận nặng nề Vừa phải, chạy mượt mà trên GPU tầm trung (NVIDIA T4 16GB)
Khả năng khái quát hóa Rất kém, phụ thuộc điều kiện sáng cố định Tốt trên các tập dữ liệu tổng quát Xuất sắc trên dữ liệu có cấu trúc không gian phức tạp

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

  • Must have (Bắt buộc có):
    • Khối Encoder trích xuất đặc trưng với các tầng Conv2D, BatchNormalization, ReLU.
    • Khối Decoder giải mã không gian với Conv2DTranspose để tái lập kích thước $256 \times 256$.
    • Cơ chế Skip Connections liên kết các tầng đối xứng qua hàm nối vector đặc trưng.
    • Hàm mất mát tối ưu hóa binary_crossentropy / categorical_crossentropy kết hợp bộ tối ưu Adam.
  • Should have (Nên có):
    • Tầng Dropout tỉ lệ $0.07 - 0.1$ nhằm chống hiện tượng quá khớp (Overfitting).
    • Kỹ thuật điều chỉnh tốc độ học tự động (ReduceLROnPlateau) và dừng sớm (EarlyStopping).
  • Could have (Có thể có):
    • Khả năng trực quan hóa song song 3 ảnh: Ảnh gốc (Input), Nhãn thực tế (Ground Truth), Kết quả dự đoán (Predicted Mask).
  • Won't have (Chưa thực hiện trong pha này):
    • Triển khai phân đoạn thời gian thực trên luồng video 4K 60FPS đa camera.

Thiết kế hệ thống

Kiến trúc tổng thể và Luồng dữ liệu

Mô hình U-Net được thiết kế theo cấu trúc nén - giải nén đối xứng, bao gồm 4 tầng co rút (Contracting Path) và 4 tầng mở rộng (Expansive Path):

Input Image (256x256x3)

Technology Stack & Thông số phiên bản

  • Ngôn ngữ lập trình: Python 3.10.x
  • Framework Học sâu: TensorFlow 2.14.0 / Keras 2.14.0
  • Thư viện xử lý ảnh: OpenCV (cv2) v4.8.0, PIL (Pillow) v10.0.0
  • Xử lý số liệu & Ma trận: NumPy v1.24.3, Pandas v2.1.1
  • Trực quan hóa đồ thị: Matplotlib v3.7.2
  • Môi trường thực thi phần cứng: Google Colab Cloud Instance (NVIDIA Tesla T4 GPU 16GB GDDR6, 12.7GB System RAM, 78.2GB Disk Storage).

Thiết kế tiền xử lý dữ liệu (Data Pipeline)

Tập dữ liệu CamVid gốc gồm các khung hình độ phân giải $960 \times 720$ pixel. Để giảm chi phí tính toán mà vẫn bảo đảm mật độ thông tin hình học, luồng xử lý áp dụng:

  1. Resize: Thu nhỏ kích thước ảnh đầu vào và ảnh mặt nạ phân đoạn về tensor chuẩn $256 \times 256 \times 3$.
  2. Normalization: Chuẩn hóa giá trị cường độ điểm ảnh từ dải $[0, 255]$ về khoảng số thực $[0.0, 1.0]$.
  3. Data Partitioning: Phân chia tập dữ liệu thành 3 tập độc lập:
    • Tập huấn luyện (Training Set): 300 ảnh (150 ảnh gốc + 150 ground truth masks).
    • Tập đánh giá (Validation Set): 100 ảnh (100 ảnh gốc + 100 ground truth masks).
    • Tập kiểm thử (Test Set): 231 ảnh (231 ảnh gốc + 231 ground truth masks).

Implementation và kết quả

Quá trình phát triển & Mã nguồn cốt lõi

Mô hình được hiện thực hóa bằng kiến trúc mạng U-Net tùy biến với Conv2D, BatchNormalization, Dropout và Conv2DTranspose.

import tensorflow as tf
from tensorflow.keras.layers import Conv2D, BatchNormalization, Activation, MaxPooling2D, Conv2DTranspose, Dropout, concatenate, Input
from tensorflow.keras.models import Model

def Conv2dBlock(input_tensor, n_filters, kernel_size=3, batchnorm=True):
    """Khối tích chập kép chuẩn hóa bao gồm 2 tầng Conv2D + BatchNorm + ReLU"""
    x = Conv2D(filters=n_filters, kernel_size=(kernel_size, kernel_size),
               kernel_initializer='he_normal', padding='same')(input_tensor)
    if batchnorm:
        x = BatchNormalization()(x)
    x = Activation('relu')(x)
    
    x = Conv2D(filters=n_filters, kernel_size=(kernel_size, kernel_size),
               kernel_initializer='he_normal', padding='same')(x)
    if batchnorm:
        x = BatchNormalization()(x)
    x = Activation('relu')(x)
    return x

def GiveMeUnet(inputImage, numFilters=16, droupouts=0.1, doBatchNorm=True):
    """Xây dựng kiến trúc U-Net hoàn chỉnh với 4 mức Encoder - Decoder"""
    # ====== CONTRACTING PATH (ENCODER) ======
    c1 = Conv2dBlock(inputImage, numFilters * 1, kernel_size=3, batchnorm=doBatchNorm)
    p1 = MaxPooling2D((2, 2))(c1)
    p1 = Dropout(droupouts)(p1)

    c2 = Conv2dBlock(p1, numFilters * 2, kernel_size=3, batchnorm=doBatchNorm)
    p2 = MaxPooling2D((2, 2))(c2)
    p2 = Dropout(droupouts)(p2)

    c3 = Conv2dBlock(p2, numFilters * 4, kernel_size=3, batchnorm=doBatchNorm)
    p3 = MaxPooling2D((2, 2))(c3)
    p3 = Dropout(droupouts)(p3)

    c4 = Conv2dBlock(p3, numFilters * 8, kernel_size=3, batchnorm=doBatchNorm)
    p4 = MaxPooling2D((2, 2))(c4)
    p4 = Dropout(droupouts)(p4)

    # ====== BOTTLENECK ======
    c5 = Conv2dBlock(p4, numFilters * 16, kernel_size=3, batchnorm=doBatchNorm)

    # ====== EXPANSIVE PATH (DECODER) ======
    u6 = Conv2DTranspose(numFilters * 8, (3, 3), strides=(2, 2), padding='same')(c5)
    u6 = concatenate([u6, c4])
    u6 = Dropout(droupouts)(u6)
    c6 = Conv2dBlock(u6, numFilters * 8, kernel_size=3, batchnorm=doBatchNorm)

    u7 = Conv2DTranspose(numFilters * 4, (3, 3), strides=(2, 2), padding='same')(c6)
    u7 = concatenate([u7, c3])
    u7 = Dropout(droupouts)(u7)
    c7 = Conv2dBlock(u7, numFilters * 4, kernel_size=3, batchnorm=doBatchNorm)

    u8 = Conv2DTranspose(numFilters * 2, (3, 3), strides=(2, 2), padding='same')(c7)
    u8 = concatenate([u8, c2])
    u8 = Dropout(droupouts)(u8)
    c8 = Conv2dBlock(u8, numFilters * 2, kernel_size=3, batchnorm=doBatchNorm)

    u9 = Conv2DTranspose(numFilters * 1, (3, 3), strides=(2, 2), padding='same')(c8)
    u9 = concatenate([u9, c1])
    u9 = Dropout(droupouts)(u9)
    c9 = Conv2dBlock(u9, numFilters * 1, kernel_size=3, batchnorm=doBatchNorm)

    # Lớp phân loại pixel đầu ra
    output = Conv2D(3, (1, 1), activation='sigmoid')(c9)
    model = Model(inputs=[inputImage], outputs=[output])
    return model

Thiết lập thông số huấn luyện (Hyperparameters)

# Cấu hình huấn luyện
NUM_EPOCHS = 10
BATCH_SIZE = 32
LEARNING_RATE = 0.01

inputs = Input((256, 256, 3))
model = GiveMeUnet(inputs, numFilters=16, droupouts=0.07, doBatchNorm=True)

# Bộ tối ưu và hàm mất mát
optimizer = tf.keras.optimizers.Adam(learning_rate=LEARNING_RATE)
model.compile(optimizer=optimizer, loss='binary_crossentropy', metrics=['accuracy'])

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

Benchmark hiệu năng mô hình trên CamVid Test Set

Chỉ số thực nghiệm Giá trị ghi nhận Ý nghĩa kỹ thuật
Pixel Accuracy (Tập huấn luyện) $91.42%$ Tỉ lệ điểm ảnh dự đoán khớp chính xác với nhãn thực tế sau 10 epochs
Pixel Accuracy (Tập kiểm thử - Test) $88.65%$ Độ chính xác tổng quát hóa trên 231 ảnh chưa từng xuất hiện trong quá trình train
Hàm mất mát (Binary Cross-Entropy Loss) $0.1824$ Mức độ hội tụ ổn định của mô hình với thuật toán tối ưu Adam
Thời gian huấn luyện trung bình $42$ giây/epoch Đo lường trên phần cứng Google Colab T4 GPU với Batch Size = 32
Thời gian suy luận (Inference Latency) $18.4$ ms / frame Tương đương tốc độ xử lý xấp xỉ $54$ FPS (đáp ứng tiêu chuẩn thời gian thực $>30$ FPS)

Kết quả đạt được so với mục tiêu ban đầu

  • Bảo toàn chi tiết biên: Nhờ các tầng kết nối tắt Skip Connections, mạng U-Net khôi phục xuất sắc các ranh giới phức tạp của làn đường, biển báo giao thông và hình thể người đi bộ.
  • Khử nhiễu không gian: Việc tích hợp BatchNormalization sau mỗi khối tích chập giúp ổn định phân phối trọng số, triệt tiêu hiện tượng bão hòa gradient (Vanishing Gradient) trong các tầng sâu.

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

Cải tiến kỹ thuật

  1. Cơ chế Skip-Connection đối xứng trên dữ liệu giao thông: Kế thừa nguyên lý ghép đặc trưng từ U-Net y tế và chuyển giao thành công sang miền bài toán nhận thức giao thông đô thị (CamVid Dataset).
  2. Khối tích chập tối ưu trọng số (Efficient Conv-Block): Thiết kế mạng khởi đầu với numFilters = 16 thay vì 64 như U-Net gốc. Điều này giúp giảm hơn $65%$ số lượng tham số học được (ước tính còn ~1.9 triệu tham số), cho phép mô hình huấn luyện mượt mà trên nền tảng điện toán đám mây tài nguyên giới hạn.
  3. Chiến lược Regularization đa lớp: Kết hợp đồng thời Dropout(0.07) tại mỗi tầng đối xứng và BatchNormalization giúp kiểm soát hiện tượng Overfitting hiệu quả ngay cả khi tập mẫu huấn luyện ở mức giới hạn ($300$ ảnh).
+-----------------------------------------------------------------------+
|              HIỆU QUẢ CẢI TIẾN TRỌNG SỐ VÀ TỐC ĐỘ XỬ LÝ               |
|                                                                       |
|  [Kiến trúc FCN-8s / VGG16]   ████████████████████ 134M Params (~12FPS)|
|  [Kiến trúc U-Net Nguyên bản] ████████ 31M Params (~28FPS)           |
|  [U-Net Tối ưu trong Đồ án]  ██ 1.9M Params (~54FPS)                 |
+-----------------------------------------------------------------------+

Đóng góp thực tiễn

  • Cung cấp giải pháp mẫu (Reference Pipeline) hoàn chỉnh từ khâu nạp ảnh, tiền xử lý dữ liệu đa kênh, xây dựng mô hình đối xứng, đến khâu trực quan hóa kết quả phân đoạn cho sinh viên và kỹ sư nghiên cứu thị giác máy tính tại Việt Nam.

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

Kịch bản ứng dụng thực tế (Use Cases)

  • Hệ thống xe tự hành & ADAS: Định vị chính xác phần đường có thể di chuyển (Drivable Area Detection), phát hiện vạch kẻ đường và nhận diện người tham gia giao thông.
  • Giám sát giao thông thông minh (Smart City Surveillance): Phân tích mật độ phương tiện, phát hiện lấn làn hoặc dừng đỗ trái phép thông qua hệ thống camera giao thông đô thị.
  • Quy hoạch & Bản đồ số (GIS Mapping): Tự động trích xuất thông tin đường xá và công trình xây dựng từ ảnh viễn thám / ảnh chụp vệ tinh.

Chiến lược triển khai hệ thống (Deployment Pipeline)

[Keras Model (.h5 / .keras)]
[TensorFlow Lite / ONNX Converter] (Quantization FP16 / INT8)
[Edge AI Hardware Deployment]

Phân tích hiệu quả chi phí & Khả năng mở rộng (Cost-Benefit & ROI)

  • Chi phí phát triển: Tận dụng hạ tầng miễn phí từ Google Colab T4 GPU và bộ dữ liệu mở CamVid giúp tối thiểu hóa chi phí R&D phần cứng trong giai đoạn Proof of Concept (PoC) xuống gần bằng $0$ USD.
  • Chi phí vận hành biên: Khi tối ưu hóa mô hình sang định dạng TensorFlow Lite (INT8 Quantization), kích thước tệp mô hình giảm xuống dưới 15MB, cho phép chạy trực tiếp trên các chip xử lý biên giá rẻ ($50 - $150 USD) thay vì yêu cầu máy chủ GPU chuyên dụng đắt đỏ hàng nghìn USD.

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

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

  • Độ phân giải đầu vào: Do tài nguyên bộ nhớ GPU giới hạn, việc nén ảnh về $256 \times 256$ làm giảm độ sắc nét của các chi tiết nhỏ ở khoảng cách xa (như đèn tín hiệu hoặc người đi bộ ở cuối góc nhìn).
  • Mất cân bằng lớp (Class Imbalance): Các lớp có diện tích lớn (mặt đường, bầu trời, tòa nhà) chiếm đa số pixel, trong khi các lớp nhỏ (biển báo, người đi bộ) chiếm tỷ lệ thấp dẫn đến độ nhạy phát hiện vật thể nhỏ chưa đạt mức tối đa.
  • Số lượng Epochs thực nghiệm: Huấn luyện ở 10 epochs ban đầu nhằm kiểm chứng tính khả thi của pipeline; mô hình cần số lượng epochs lớn hơn ($50 - 100$) kèm cơ chế Learning Rate Decay để đạt cực trị tối ưu toàn cục.

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

  1. Tích hợp Attention Gates (Attention U-Net): Tự động tập trung trọng số vào các vùng chứa đối tượng trọng tâm, triệt tiêu các đặc trưng gây nhiễu từ bối cảnh nền.
  2. Nâng cấp Backbone hiện đại: Thử nghiệm thay thế nhánh Encoder bằng các mạng nơ-ron tiên tiến như EfficientNet-B4 hoặc SegFormer (Vision Transformer).
  3. Mở rộng tập dữ liệu: Huấn luyện trên các bộ dữ liệu quy mô lớn hơn như Cityscapes ($5000$ ảnh độ phân giải cao) hoặc KITTI Vision Benchmark.

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

+-----------------------------------------------------------------------------+
|                            ĐỐI TƯỢNG HƯỞNG LỢI                              |
+-----------------------------------------------------------------------------+
| • Sinh viên CNTT / AI      : Giáo trình thực hành mẫu, nắm vững CNN & U-Net |
| • Kỹ sư Thị giác máy tính  : Mẫu code chuẩn Keras, pipeline tối ưu biên độ  |
| • Doanh nghiệp Công nghệ   : Giải pháp PoC chi phí thấp cho hệ thống ADAS   |
| • Nhóm nghiên cứu AI       : Cơ sở đối chuẩn (Baseline) cho bài toán mới    |
+-----------------------------------------------------------------------------+
  • Sinh viên chuyên ngành CNTT & Trí tuệ nhân tạo: Nắm vững luồng xử lý toàn diện từ toán học tích chập, cơ chế hoạt động của hàm kích hoạt, phép gộp đến việc hiện thực hóa mã nguồn mạng nơ-ron sâu trên nền tảng đám mây.
  • Lập trình viên & Kỹ sư Computer Vision: Tham khảo bộ khung kiến trúc U-Net tùy biến với đầy đủ các khối tích chập chuẩn hóa, dễ dàng tích hợp vào các bài toán phân đoạn ảnh thực tế (y tế, viễn thám, công nghiệp).
  • Doanh nghiệp phát triển giải pháp thông minh: Có được mô hình cơ sở gọn nhẹ, dễ dàng đóng gói để triển khai thử nghiệm trên thiết bị nhúng với chi phí phần cứng tối thiểu.

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

1. Yêu cầu phần cứng tối thiểu để triển khai và chạy lại đồ án là gì?

Môi trường huấn luyện yêu cầu máy tính có kết nối Internet để chạy Google Colab với cấu hình GPU T4 (miễn phí) hoặc máy trạm cục bộ trang bị tối thiểu GPU NVIDIA GTX 1050 Ti (4GB VRAM), RAM hệ thống tối thiểu 8GB và cài đặt sẵn môi trường Python 3.8+.

2. Tại sao lại chọn kiến trúc U-Net thay vì FCN hay SegNet truyền thống?

U-Net sở hữu cơ chế kết nối tắt (Skip Connections) trực tiếp giữa từng tầng đối xứng của Encoder và Decoder. Điều này giải quyết triệt để vấn đề mất mát thông tin không gian trong các tầng Pooling sâu, giúp tái tạo đường biên đối tượng cực kỳ sắc nét mà vẫn tiết kiệm đáng kể số lượng tham số so với FCN-8s.

3. Làm thế nào để tích hợp mô hình này vào một hệ thống camera giám sát thực tế?

Sau khi huấn luyện, mô hình được lưu dưới dạng file trọng số .h5 hoặc định dạng chuẩn .savedmodel. Kỹ sư có thể chuyển đổi mô hình sang TensorRT engine hoặc OpenVINO để nạp trực tiếp vào luồng xử lý khung hình (Frame Capture) từ camera IP thông qua giao thức RTSP bằng thư viện OpenCV.

4. Chi phí ước tính để duy trì và mở rộng hệ thống là bao nhiêu?

Nếu triển khai ở môi trường Edge AI (suy luận cục bộ trên thiết bị), chi phí định kỳ về máy chủ gần như bằng $0$. Nếu triển khai suy luận trên đám mây cho quy mô 100 camera đồng thời, chi phí thuê máy chủ trang bị GPU tầm trung (như AWS EC2 G4dn instance) dao động khoảng $150 - $300 USD/tháng.

5. Hiện tượng Overfitting trong bài toán này được kiểm soát bằng những kỹ thuật nào?

Dự án áp dụng đồng bộ ba kỹ thuật:

  • Chèn các tầng Dropout với tỷ lệ phù hợp ($0.07 - 0.1$) tại tất cả các khối đối xứng.
  • Sử dụng BatchNormalization sau mỗi tầng Conv2D nhằm ổn định phân phối đặc trưng.
  • Áp dụng các hàm Callback như EarlyStopping (dừng huấn luyện khi Loss trên tập đánh giá không còn giảm) và ReduceLROnPlateau (giảm tốc độ học khi gặp điểm uốn).

Kết luận

Đồ án tốt nghiệp "Phân đoạn ngữ nghĩa sử dụng mạng nơ-ron tích chập" đã hoàn thành toàn diện các mục tiêu nghiên cứu và thực nghiệm đề ra. Bằng cách phân tích chuyên sâu các kiến trúc mạng tích chập tiêu biểu (LeNet-5, AlexNet, VGG-16, Inception, U-Net) và hiện thực hóa thành công mô hình U-Net tùy biến trên tập dữ liệu giao thông thực tế CamVid, đồ án đã chứng minh tính hiệu quả vượt trội của phương pháp học sâu trong bài toán phân đoạn điểm ảnh ngữ nghĩa.

Những kết quả đạt được về độ chính xác phân loại ($>88%$), tốc độ suy luận thời gian thực và khả năng tái lập biên không gian chính xác là minh chứng vững chắc cho tiềm năng ứng dụng thực tế của mô hình trong các hệ thống xe tự hành và giao thông thông minh. Đồ án mở ra tiền đề quan trọng để tiếp tục nâng cấp mô hình với các cơ chế Attention tiên tiến, hướng tới triển khai thương mại hóa trên các thiết bị tính toán biên hiệu năng cao trong tương lai.