Giới thiệu dự án

Trong kỷ nguyên số hóa và sự bùng nổ của trí tuệ nhân tạo (Artificial Intelligence - AI), thị giác máy tính (Computer Vision) đã trở thành một trong những lĩnh vực mũi nhọn thúc đẩy chuyển đổi số trong đời sống và công nghiệp. Theo các báo cáo thị trường công nghệ, lượng dữ liệu hình ảnh kỹ thuật số toàn cầu tăng trưởng hơn 25% mỗi năm, đặt ra yêu cầu cấp thiết về các hệ thống phân loại dữ liệu trực quan tự động, chuẩn xác và có khả năng mở rộng. Đồ án tốt nghiệp "Phân loại hình ảnh động vật sử dụng mạng nơ-ron tích chập và ứng dụng" do sinh viên Trần Hải Thành (Lớp CT2401C, Ngành Công nghệ Thông tin, Trường Đại học Quản lý và Công nghệ Hải Phòng) thực hiện dưới sự hướng dẫn của TS. Ngô Trường Giang, tập trung giải quyết bài toán nhận dạng và phân loại tự động hình ảnh sinh vật thực tế dựa trên nền tảng Học sâu (Deep Learning).

                      +------------------------------------------+
                      |         Kaggle Dog-vs-Cat Dataset        |
                      |          (9,896 RGB Images / 2 Classes)  |
                      +------------------------------------------+
                                           |
                                           v
                      +------------------------------------------+
                      |     Tiền xử lý & Chuẩn hóa dữ liệu       |
                      |   (Rescale 1/255, Target Size 128x128)   |
                      +------------------------------------------+
                                           |
                                           v
                      +------------------------------------------+
                      |    Kiến trúc Deep CNN Tùy chỉnh (Keras)  |
                      |  (Conv2D + BatchNorm + MaxPool + Dropout)|
                      +------------------------------------------+
                                           |
                                           v
                      +------------------------------------------+
                      |   Huấn luyện & Tối ưu hóa (Adam / LR)    |
                      |    (ReduceLROnPlateau, Binary CE Loss)   |
                      +------------------------------------------+
                                           |
                                           v
                      +------------------------------------------+
                      |  Đánh giá & Module Dự đoán Đơn ảnh      |
                      |   (Accuracy: 75.86%, Latency: ~35ms)     |
                      +------------------------------------------+

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

Phương pháp phân loại và kiểm kê hình ảnh truyền thống dựa vào con người hoặc các kỹ thuật trích xuất đặc trưng thủ công (Handcrafted Feature Extraction) bộc lộ những hạn chế nghiêm trọng:

  • Tốn kém nhân lực và thời gian: Phân loại thủ công hàng ngàn bức ảnh tiêu tốn nhiều giờ lao động, không khả thi khi triển khai trên quy mô lớn.
  • Sai số lớn do tính biến thiên cao: Dữ liệu hình ảnh động vật ngoài tự nhiên chịu ảnh hưởng lớn từ góc chụp, điều kiện ánh sáng, sự che khuất (occlusion), và độ đa dạng về tư thế, kích thước của đối tượng.
  • Giới hạn của thuật toán Machine Learning cổ điển: Các phương pháp như SVM (Support Vector Machine) hay Random Forest khi kết hợp cùng bộ trích xuất đặc trưng SIFT/HOG thường suy giảm độ chính xác rõ rệt khi gặp dữ liệu nhiễu và không gian chiều cao.

Mục tiêu đề tài (Project Objectives)

Đề tài xác định 4 mục tiêu kỹ thuật cụ thể:

  1. Nghiên cứu cơ sở lý thuyết: Hệ thống hóa nền tảng toán học và kỹ thuật của Học máy (Machine Learning), Học sâu (Deep Learning) và kiến trúc Mạng nơ-ron tích chập (Convolutional Neural Network - CNN).
  2. Thiết kế và xây dựng Pipeline xử lý dữ liệu: Xây dựng quy trình tự động đọc, tiền xử lý, chuẩn hóa không gian màu và phân chia dữ liệu từ tập dữ liệu quy mô gần 10.000 ảnh.
  3. Xây dựng mô hình Deep CNN tối ưu: Thiết kế kiến trúc CNN tuần tự tích hợp kỹ thuật ổn định gradient (Batch Normalization) và chống hiện tượng quá khớp (Dropout).
  4. Huấn luyện, đánh giá và xây dựng module ứng dụng: Triển khai huấn luyện trên hạ tầng tăng tốc phần cứng, tinh chỉnh siêu tham số với bộ điều chỉnh tốc độ học thích ứng (ReduceLROnPlateau), đạt độ chính xác kiểm thử trên 75% và đóng gói hàm suy luận dự đoán đơn ảnh (pred_single).

Phương pháp tiếp cận (Solution Approach)

Đề tài tiếp cận bài toán thông qua mô hình Deep CNN tùy biến được xây dựng trên nền tảng Keras/TensorFlow. CNN có khả năng tự động học các biểu diễn phân cấp đặc trưng (Hierarchical Feature Representation) – từ các cạnh, góc cơ bản ở tầng đầu đến các cấu trúc phức tạp như tai, mắt, mũi, họa tiết lông ở các tầng sâu – giúp khắc phục hoàn toàn nhược điểm trích xuất đặc trưng thủ công.

Phạm vi và giới hạn (Scope & Limitations)

  • Phạm vi dữ liệu: Bộ dữ liệu gồm 9.896 ảnh động vật nhị phân (Chó và Mèo) thu thập từ nền tảng Kaggle, chia thành 5.011 ảnh mèo và 4.885 ảnh chó.
  • Hạ tầng thực nghiệm: Triển khai trên môi trường Google Colaboratory với phần cứng T4 GPU (16GB VRAM), RAM hệ thống 12.7GB.
  • Giới hạn: Hệ thống tập trung tối ưu cho bài toán phân loại nhị phân (Binary Classification) với định dạng ảnh đầu vào chuẩn hóa kích thước 128x128 pixel, chưa mở rộng sang nhận diện đa lớp (Multi-class) hoặc định vị đối tượng (Object Detection/Bounding Box).

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

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

Để lựa chọn giải pháp tối ưu cho bài toán thị giác máy tính, đồ án đã tiến hành đánh giá so sánh giữa các phương pháp tiếp cận phổ biến:

Phương pháp Ưu điểm Nhược điểm Độ chính xác trung bình Khả năng mở rộng
Trích xuất đặc trưng cổ điển (HOG/SIFT + SVM) Tiêu tốn ít tài nguyên tính toán, hoạt động ổn định trên tập dữ liệu rất nhỏ. Phụ thuộc nặng nề vào chuyên gia định nghĩa đặc trưng thủ công; dễ lỗi khi nền ảnh phức tạp. 55% – 62% Rất thấp
Mạng nơ-ron truyền thẳng (FNN / MLP) Cấu trúc đơn giản, dễ cài đặt và tính toán nhanh với dữ liệu dạng bảng hoặc vector phẳng. Mất mát hoàn toàn thông tin không gian (Spatial Context); số lượng tham số bùng nổ khi ảnh kích thước lớn. 60% – 68% Thấp
Mạng nơ-ron tích chập tùy chỉnh (Custom Deep CNN) Tự động rút trích đặc trưng phân cấp, chia sẻ trọng số (Weight Sharing), bất biến tịnh tiến cục bộ. Yêu cầu tài nguyên huấn luyện GPU, cần tối ưu chống overfitting khi dữ liệu trung bình. 75% – 85% Rất cao

Yêu cầu hệ thống theo mô hình MoSCoW

  • Must Have (Bắt buộc phải có): Pipeline nạp và chuẩn hóa dữ liệu từ thư mục cấu trúc chuẩn; kiến trúc mạng CNN nhiều tầng trích xuất đặc trưng; cơ chế tối ưu hóa Adam kết hợp Binary Crossentropy; module suy luận cho một ảnh đầu vào bất kỳ.
  • Should Have (Nên có): Cơ chế tự động giảm tốc độ học thích ứng (ReduceLROnPlateau) khi độ chính xác kiểm định đi vào điểm bão hòa; các tầng Regularization (BatchNormalization, Dropout) để kiểm soát hiện tượng quá khớp.
  • Could Have (Có thể có): Khả năng tăng cường dữ liệu ảnh trực tiếp (Data Augmentation) với xoay, lật, phóng to ảnh; giao diện người dùng tương tác trực quan.
  • Won't Have (Chưa thực hiện ở giai đoạn này): Triển khai mô hình sang định dạng nhúng Edge AI vi điều khiển hoặc phân loại thời gian thực qua luồng RTSP Camera.

Thiết kế hệ thống

Kiến trúc tổng thể và luồng xử lý (Inference Pipeline)

Kiến trúc hệ thống được thiết kế theo luồng khép kín từ dữ liệu thô đến đầu ra phân lớp xác suất:

[Raw Image (JPEG/PNG)] 
        |
        v
[Resize (128x128x3)] ---> [Rescale (1/255.0)] ---> [Expand Dims (1, 128, 128, 3)]
        |
        v
[Input Conv2D Layer (32 Filters, 3x3, ReLU)]
        |
        v
[Batch Normalization] ---> [Max Pooling (2x2)] ---> [Dropout (0.25)]
        |
        v
[Hidden Conv2D Layer (64 Filters, 3x3, ReLU)]
        |
        v
[Batch Normalization] ---> [Max Pooling (2x2)] ---> [Dropout (0.25)]
        |
        v
[Flatten Layer] ---> [Dense Layer (512 Units, ReLU)] ---> [Dropout (0.5)]
        |
        v
[Output Dense Layer (2 Units, Softmax)] ---> [Argmax] ---> Label Result ("cat" / "dog")

Chi tiết Tech Stack và công nghệ sử dụng

Thành phần Công nghệ / Thư viện Phiên bản khuyến nghị Vai trò trong hệ thống
Ngôn ngữ cốt lõi Python >= 3.10 Lập trình logic, xử lý luồng thuật toán chính.
Framework Deep Learning TensorFlow / Keras >= 2.12.0 Xây dựng kiến trúc mô hình, biên dịch và huấn luyện mạng CNN.
Xử lý ma trận & dữ liệu NumPy / Pandas >= 1.23 / >= 2.0 Thao tác mảng đa chiều tensor, tổ chức bảng dữ liệu kiểm thử.
Xử lý thị giác OpenCV (cv2) / PIL >= 4.7.0 Đọc ảnh thô, chuyển đổi không gian màu, co dãn kích thước ma trận.
Trực quan hóa Matplotlib >= 3.7.0 Biểu diễn phân phối dữ liệu, vẽ biểu đồ học tập và kết quả dự đoán.
Hạ tầng điện toán đám mây Google Colaboratory Cloud Instance Cung cấp môi trường thực thi Jupyter và bộ tăng tốc đồ họa NVIDIA T4.

Phương pháp luận phát triển (Methodology)

Đề tài áp dụng quy trình phát triển lặp theo tiêu chuẩn nghiên cứu khoa học dữ liệu ứng dụng (CRISP-DM - Cross-Industry Standard Process for Data Mining):

  1. Phân tích bài toán: Định nghĩa bài toán phân lớp nhị phân trên không gian ảnh màu RGB.
  2. Khám phá và tiền xử lý dữ liệu: Đánh giá sự cân bằng giữa 2 lớp (Cats: 50.6%, Dogs: 49.4%), chuẩn hóa giá trị điểm ảnh từ $[0, 255]$ về khoảng $[0.0, 1.0]$.
  3. Mô hình hóa (Modeling): Xây dựng cấu trúc tuần tự kết hợp các tầng tích chập, tinh chỉnh kích thước bộ lọc và tỷ lệ Dropout.
  4. Đánh giá thực nghiệm (Evaluation): Sử dụng các thước đo Accuracy, Confusion Matrix và thực hiện 10 đợt kiểm thử độc lập trên tập mẫu ngẫu nhiên.

Implementation và kết quả

Quy trình phát triển và chi tiết thuật toán cốt lõi

Toán học của các tầng trong mạng tích chập

Mạng nơ-ron tích chập sử dụng phép toán nhân chập 2D rời rạc để trích xuất ma trận đặc trưng (Feature Map) từ ma trận đầu vào $I$ với bộ lọc (Kernel) $K$ kích thước $k \times k$:

$$S(i, j) = (I * K)(i, j) = \sum_{m} \sum_{n} I(i - m, j - n) K(m, n)$$

Sau phép tích chập, hàm kích hoạt phi tuyến tính ReLU (Rectified Linear Unit) được áp dụng để loại bỏ các giá trị âm, giúp mô hình học được các quan hệ phi tuyến phức tạp:

$$f(x) = \max(0, x)$$

Hàm mất mát Binary Cross-Entropy được sử dụng để tối ưu hóa trọng số mô hình:

$$\mathcal{L}{BCE} = -\frac{1}{N} \sum{i=1}^{N} \left[ y_i \log(\hat{y}_i) + (1 - y_i) \log(1 - \hat{y}_i) \right]$$

1. Tiền xử lý và tạo luồng dữ liệu (Data Pipeline)

Dữ liệu được chuẩn hóa và nạp theo từng batch nhằm tối ưu hóa việc sử dụng bộ nhớ RAM/VRAM:

import os
import cv2
import numpy as np
import tensorflow as tf
from tensorflow.keras.preprocessing.image import ImageDataGenerator

# Thiết lập các siêu tham số đầu vào
image_size = 128      # Kích thước chuẩn hóa (Height = Width = 128px)
image_channel = 3     # Định dạng 3 kênh màu RGB
bat_size = 32         # Kích thước mỗi batch huấn luyện

# Khởi tạo bộ sinh dữ liệu và chuẩn hóa điểm ảnh về khoảng [0, 1]
train_datagen = ImageDataGenerator(rescale=1./255)
test_datagen = ImageDataGenerator(rescale=1./255)

# Nạp dữ liệu huấn luyện tự động theo cấu trúc thư mục
train_gen = train_datagen.flow_from_directory(
    '/content/drive/MyDrive/Dog-vs-Cat/data/training_set/',
    class_mode='categorical',
    target_size=(image_size, image_size),
    batch_size=bat_size
)

# Nạp dữ liệu kiểm thử
val_gen = test_datagen.flow_from_directory(
    '/content/drive/MyDrive/Dog-vs-Cat/data/test_set/',
    class_mode='categorical',
    batch_size=bat_size,
    target_size=(image_size, image_size),
    shuffle=False
)

2. Xây dựng kiến trúc mô hình Deep CNN (Model Definition)

Cấu trúc mạng bao gồm các khối tích chập kép tăng dần số lượng bộ lọc (32 $\rightarrow$ 64 filters) nhằm nắm bắt từ đặc trưng cục bộ mức thấp đến các đặc trưng toàn cục mức cao:

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

# Khởi tạo mô hình tuần tự
model = Sequential()

# --- Tầng Input & Khối tích chập 1 ---
model.add(Conv2D(32, kernel_size=(3, 3), activation='relu', input_shape=(image_size, image_size, image_channel)))
model.add(BatchNormalization())
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))

# --- Khối tích chập ẩn 2 ---
model.add(Conv2D(64, kernel_size=(3, 3), activation='relu'))
model.add(BatchNormalization())
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))

# --- Tầng kết nối đầy đủ (Fully Connected Layers) ---
model.add(Flatten())
model.add(Dense(512, activation='relu'))
model.add(BatchNormalization())
model.add(Dropout(0.5))

# --- Tầng Output ---
model.add(Dense(2, activation='softmax'))

# Hiển thị cấu trúc chi tiết
model.summary()

3. Biên dịch và Tối ưu hóa Siêu tham số (Compilation & Training)

Sử dụng Callback ReduceLROnPlateau để tự động giảm tốc độ học khi độ chính xác trên tập kiểm tra chững lại:

from tensorflow.keras.callbacks import ReduceLROnPlateau

# Cấu hình hàm Callback giám sát val_accuracy
learning_rate_reduction = ReduceLROnPlateau(
    monitor='val_accuracy',
    patience=2,
    factor=0.00001,
    verbose=1
)

# Biên dịch mô hình với thuật toán tối ưu Adam
model.compile(
    optimizer='adam',
    loss='binary_crossentropy',
    metrics=['accuracy']
)

# Tiến hành huấn luyện mô hình qua 10 Epochs
history = model.fit(
    train_gen,
    validation_data=val_gen,
    callbacks=[learning_rate_reduction],
    epochs=10
)

# Lưu trữ trọng số mô hình đã huấn luyện
model.save("/content/drive/MyDrive/Dog-vs-Cat/model.h5")

4. Module suy luận dự đoán đơn ảnh (Single Image Inference Pipeline)

from matplotlib.pyplot import imread

def pred_single(path):
    """
    Hàm đọc ảnh từ đường dẫn, tiền xử lý và trả về nhãn dự đoán cùng ma trận ảnh
    """
    img = imread(path)
    # Chuyển đổi kích thước về chuẩn 128x128
    resized_image = cv2.resize(img, (image_size, image_size))
    # Mở rộng chiều tensor để tạo batch dạng (1, 128, 128, 3)
    resized_image = np.expand_dims(resized_image, axis=0)
    # Chuẩn hóa giá trị điểm ảnh
    rescaled_image = resized_image / 255.0
    
    # Thực hiện dự đoán xác suất
    predictions = model.predict(rescaled_image)
    predicted_class = np.argmax(predictions)
    
    # Gán nhãn kết quả
    if predicted_class == 0:
        pred = 'cat'
    else:
        pred = 'dog'
        
    return [img, pred]

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

Đánh giá tổng thể mô hình

Khi kiểm thử trên toàn bộ tập dữ liệu test độc lập thông qua phương thức model.evaluate(), mô hình đạt độ chính xác 75.86%.

Kết quả 10 đợt kiểm thử ngẫu nhiên trên tập Test

Thực nghiệm tiến hành 10 đợt kiểm thử độc lập, mỗi đợt lấy ngẫu nhiên 5 ảnh từ tập kiểm thử để phân loại:

Đợt Test Số ảnh đúng Số ảnh sai Tổng số ảnh Tỷ lệ chính xác (%)
Test 1 4 1 5 80%
Test 2 3 2 5 60%
Test 3 3 2 5 60%
Test 4 4 1 5 80%
Test 5 3 2 5 60%
Test 6 3 2 5 60%
Test 7 3 2 5 60%
Test 8 4 1 5 80%
Test 9 3 2 5 60%
Test 10 3 2 5 60%
Trung bình 3.3 1.7 5 66.0%

Độ chính xác phân loại trong các đợt mẫu nhỏ dao động từ 60% đến 80%, với mức trung bình đạt 66.0%, phản ánh sát với hiệu năng tổng thể trên toàn tập test (75.86%).

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

Điểm nổi bật về giải pháp kỹ thuật

  1. Cấu trúc Regularization đa tầng kết hợp: Việc xếp lớp xen kẽ BatchNormalization ngay sau các tầng Conv2D và Dense, kết hợp với tỷ lệ Dropout (0.25 cho Conv block và 0.5 cho Dense block) đã giải quyết triệt để sự mất cân bằng phân phối đầu vào nội tại (Internal Covariate Shift), giúp mạng hội tụ nhanh và triệt tiêu đáng kể hiện tượng quá khớp trên tập dữ liệu dưới 10.000 mẫu.
  2. Cơ chế điều chỉnh tốc độ học thích ứng động: Việc tích hợp ReduceLROnPlateau với hệ số suy giảm $factor = 10^{-5}$ sau mỗi $patience = 2$ epoch không có tiến triển giúp mô hình tinh chỉnh bước nhảy trọng số khi tiếp cận cực tiểu toàn cục của hàm mất mát.

So sánh hiệu năng với các giải pháp khác

Tiêu chí HOG + SVM Baseline Mạng nơ-ron đa tầng (MLP) Mô hình CNN của Đề tài
Thời gian trích xuất đặc trưng Rất lâu (thủ công từng ảnh) Nhanh (làm phẳng vector) Tự động trong quá trình lan truyền tiến
Khả năng bất biến hình học Kém khi vật thể xoay/nghiêng Rất kém Tốt nhờ cơ chế Max-Pooling
Số lượng tham số học Cố định theo số chiều HOG Rất lớn (Bùng nổ nơ-ron) Tối ưu nhờ chia sẻ trọng số (Kernel)
Độ chính xác kiểm thử (Accuracy) 58.40% 63.20% 75.86% (+12.66% so với MLP)

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

Kịch bản ứng dụng trong thực tiễn (Use Cases)

  • Hệ thống phân loại và quản lý vật nuôi thông minh: Ứng dụng tại các trạm cứu hộ động vật, phòng khám thú y để tự động gắn nhãn hồ sơ thú cưng khi tiếp nhận hình ảnh.
  • Camera bẫy ảnh sinh thái (Wildlife Camera Trapping): Tích hợp vào hệ thống giám sát tự động để lọc bỏ các ảnh không có mục tiêu nghiên cứu hoặc phân loại sơ bộ các loài động vật trong khu bảo tồn.
  • Sàn thương mại điện tử chuyên ngành thú cưng: Tự động nhận diện danh mục sản phẩm phù hợp (thức ăn, phụ kiện cho chó hoặc mèo) khi người dùng tải ảnh tìm kiếm.

Kiến trúc triển khai dịch vụ Web / API

Mô hình có thể được đóng gói và triển khai trên hạ tầng đám mây theo kiến trúc Microservices:

# Ví dụ triển khai Endpoint API với FastAPI
from fastapi import FastAPI, File, UploadFile
import uvicorn
import io
from PIL import Image

app = FastAPI(title="Animal Classification API")

@app.post("/predict")
async def predict_image(file: UploadFile = File(...)):
    contents = await file.read()
    image = Image.open(io.BytesIO(contents)).convert('RGB')
    image = image.resize((128, 128))
    img_array = np.expand_dims(np.array(image) / 255.0, axis=0)
    
    preds = model.predict(img_array)
    class_idx = np.argmax(preds)
    label = "cat" if class_idx == 0 else "dog"
    confidence = float(np.max(preds))
    
    return {"class": label, "confidence": round(confidence, 4)}

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

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

  • Phân loại nhị phân cơ bản: Mô hình hiện chỉ phân biệt được 2 lớp (Chó và Mèo), chưa thể phân loại các phân loài cụ thể (Breed Classification) hoặc mở rộng sang các loài động vật hoang dã khác.
  • Kích thước ảnh đầu vào nhỏ (128x128): Việc giảm kích thước ảnh về 128x128 giúp tiết kiệm bộ nhớ huấn luyện nhưng làm mất mát một phần chi tiết vân lông và kết cấu mắt nhỏ.
  • Độ chính xác 75.86%: Mức độ chính xác này phù hợp với mô hình huấn luyện từ đầu (Train from scratch) với số lượng lớp nhỏ, nhưng còn khoảng cách so với các mô hình học chuyển giao (Transfer Learning) tiền huấn luyện.

Hướng nâng cấp và phát triển tương lai

  1. Áp dụng Transfer Learning & Fine-tuning: Tận dụng các backbone mạng hiện đại đã tiền huấn luyện trên tập ImageNet như MobileNetV3, ResNet-50 hoặc EfficientNet-B0 để nâng độ chính xác lên trên 92% mà vẫn đảm bảo tính gọn nhẹ.
  2. Ứng dụng kỹ thuật Data Augmentation mở rộng: Tích hợp các phép biến đổi ảnh nâng cao (MixUp, CutMix, RandomRotation, ColorJitter) để tăng khả năng chống chịu nhiễu của mô hình.
  3. Tối ưu hóa Edge AI: Chuyển đổi định dạng mô hình sang TensorFlow Lite (TFLite) hoặc ONNX kết hợp lượng tử hóa trọng số (Quantization INT8) để triển khai trực tiếp trên thiết bị nhúng (Raspberry Pi, Jetson Nano, Mobile App).

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

                   +--------------------------------------------+
                   |             Đối tượng hưởng lợi            |
                   +--------------------------------------------+
                                  /       |       \
                                 /        |        \
                                v         v         v
        +-------------------------+  +---------+  +-------------------------+
        | Sinh viên & Người học   |  | Lập     |  | Doanh nghiệp            |
        | - Template mẫu Deep CNN |  | trình   |  | - Blueprint tự động hóa |
        | - Hiểu sâu Tensor/Keras |  | viên    |  | - Giảm 70% chi phí gán  |
        +-------------------------+  +---------+  |   nhãn ảnh thủ công     |
                                          |       +-------------------------+
                                          v
                              +-------------------------+
                              | - Codebase chuẩn hóa    |
                              | - Tích hợp API nhanh    |
                              +-------------------------+
  • Sinh viên và Người tự học AI/ML: Nắm bắt trực quan toàn bộ quy trình xây dựng bài toán Computer Vision thực chiến từ khâu đọc dữ liệu Kaggle, thiết kế mạng CNN cho đến đánh giá kết quả thực nghiệm.
  • Kỹ sư phần mềm & Lập trình viên AI: Sở hữu mẫu codebase chuẩn hóa về pipeline Keras, các hàm tiền xử lý ma trận ảnh và kỹ thuật xử lý callback thích ứng có thể tái sử dụng ngay.
  • Doanh nghiệp và Tổ chức: Có được giải pháp cơ sở để xây dựng các hệ thống nhận dạng thị giác tự động với chi phí đầu tư phần cứng thấp, giảm thiểu 70% thời gian phân loại dữ liệu ảnh thủ công.

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

1. Cấu hình phần cứng tối thiểu để huấn luyện và triển khai mô hình này là gì?

Quá trình huấn luyện khuyến nghị sử dụng GPU có từ 4GB VRAM trở lên (hoặc sử dụng miễn phí T4 GPU trên Google Colab). Đối với quá trình suy luận (Inference/Deploy), mô hình chỉ tiêu tốn khoảng 150MB RAM và có thể chạy mượt mà trên CPU thông thường với độ trễ dưới 50ms/ảnh.

2. Tại sao mô hình lại sử dụng kích thước ảnh 128x128 thay vì giữ nguyên độ phân giải gốc?

Ảnh gốc trong tập dữ liệu Kaggle có kích thước không đồng đều. Chuẩn hóa về $128 \times 128 \times 3$ giúp cân bằng giữa việc giữ lại các đặc trưng trực quan quan trọng và kiểm soát lượng tham số tính toán của ma trận, tránh gây quá tải bộ nhớ VRAM trong quá trình truyền tiến và lan truyền ngược.

3. Làm thế nào để mở rộng mô hình từ 2 lớp (Chó/Mèo) sang bài toán phân loại hàng chục loài động vật khác nhau?

Cần thực hiện 2 thay đổi chính trong mã nguồn: (1) Thay đổi số nơ-ron tại tầng Dense cuối cùng từ model.add(Dense(2, ...)) thành model.add(Dense(N, ...)) với $N$ là số lớp; (2) Giữ nguyên hàm kích hoạt softmax và chuyển hàm mất mát sang categorical_crossentropy.

4. Tác dụng cụ thể của lớp BatchNormalization trong kiến trúc CNN là gì?

BatchNormalization thực hiện chuẩn hóa dữ liệu đầu ra của các tầng tích chập theo từng mini-batch về phân phối chuẩn có kỳ vọng bằng 0 và phương sai bằng 1. Kỹ thuật này giúp giải quyết hiện tượng bão hòa gradient, cho phép thiết lập tốc độ học lớn hơn và đóng vai trò như một bộ điều hòa nhẹ giúp giảm quá khớp.

5. Sự khác biệt giữa hàm mất mát Binary Cross-Entropy và Categorical Cross-Entropy là gì?

Binary Cross-Entropy được thiết kế tối ưu cho các bài toán phân lớp nhị phân (2 lựa chọn đầu ra độc lập), tính toán mất mát dựa trên phân phối xác suất Bernoulli. Trong khi đó, Categorical Cross-Entropy áp dụng cho bài toán đa lớp rời rạc ($N \ge 3$) dựa trên phân phối xác suất Multinomial.

Kết luận

Đồ án tốt nghiệp "Phân loại hình ảnh động vật sử dụng mạng nơ-ron tích chập và ứng dụng" của tác giả Trần Hải Thành đã hoàn thành toàn diện các mục tiêu đề ra: từ việc nghiên cứu tổng quan hệ thống lý thuyết Học máy/Học sâu, xây dựng thành công pipeline xử lý dữ liệu quy mô 9.896 ảnh, cho đến việc thiết kế và tối ưu hóa mạng Deep CNN đạt độ chính xác 75.86% trên tập kiểm thử thực tế.

Công trình không chỉ mang giá trị học thuật cao trong việc làm sáng tỏ cơ chế hoạt động của các tầng tích chập, bộ chuẩn hóa lô và hàm suy giảm tốc độ học thích ứng, mà còn mang tính ứng dụng thực tiễn rõ rệt thông qua việc hoàn thiện module phân loại ảnh đơn lẻ. Đây là nền tảng kỹ thuật vững chắc để tiếp tục mở rộng sang các hệ thống nhận dạng thị giác máy tính thông minh, đa đối tượng và đa nền tảng trong tương lai.