Giới thiệu dự án

Thị giác máy tính (Computer Vision) và Trí tuệ nhân tạo (AI) đang tạo nên cuộc cách mạng sâu rộng trong kỷ nguyên số hóa. Theo báo cáo từ Grand View Research, quy mô thị trường thị giác máy tính toàn cầu đạt 14,10 tỷ USD vào năm 2022 và dự kiến đạt tốc độ tăng trưởng kép hàng năm (CAGR) 16,0% từ năm 2023 đến 2030. Trong đó, bài toán nhận dạng và phân loại hình ảnh (Image Classification) đóng vai trò nền tảng cho hàng loạt ứng dụng thông minh như xe tự hành, chẩn đoán y tế tự động, giám sát an ninh và nông nghiệp công nghệ cao.

Tuy nhiên, việc phân loại hình ảnh đối tượng sinh học phức tạp như động vật đặt ra nhiều thách thức lớn:

  • Biến dạng hình thái và tư thế: Động vật có tính linh hoạt cao, góc chụp đa dạng và cử động liên tục.
  • Nhiễu nền phức tạp: Môi trường tự nhiên chứa nhiều chi tiết tương đồng về màu sắc và kết cấu với chủ thể.
  • Sự bùng nổ chiều dữ liệu: Các phương pháp học máy truyền thống (Traditional Machine Learning) dựa vào trích xuất đặc trưng thủ công (Handcrafted Features) bộc lộ sự kém thích ứng và chi phí tính toán cao khi xử lý ảnh độ phân giải cao.

Đồ án tốt nghiệp ngành Công nghệ Thông tin với đề tài "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 thực hiện dưới sự hướng dẫn của TS. Ngô Trường Giang (Đại học Quản lý và Công nghệ Hải Phòng) đã tập trung giải quyết triệt để các rào cản trên. Dự án đặt ra 5 mục tiêu cụ thể:

  1. Nghiên cứu tổng quan lý thuyết về Trí tuệ nhân tạo (AI), Học máy (Machine Learning), và Học sâu (Deep Learning).
  2. Phân tích chuyên sâu cấu trúc và cơ chế hoạt động của Mạng nơ-ron tích chập (Convolutional Neural Network - CNN).
  3. Thu thập và tiền xử lý bộ dữ liệu ảnh động vật thực tế (Dog-vs-Cat) với quy mô 9.896 ảnh từ nền tảng Kaggle.
  4. Thiết kế, xây dựng và huấn luyện mô hình Deep Learning sử dụng kiến trúc CNN kết hợp các kỹ thuật tối ưu hóa hiện đại như Batch Normalization, Dropout và Learning Rate Scheduling.
  5. Triển khai thử nghiệm, đánh giá định lượng hiệu năng mô hình trên tập kiểm thử độc lập và xây dựng module dự đoán ảnh thực tế.

Giải pháp sử dụng mạng nơ-ron tích chập (CNN) được lựa chọn nhờ khả năng học biểu diễn phân cấp (Hierarchical Feature Representation), tự động trích xuất từ các đặc trưng biên cạnh cơ bản (Low-level features) đến các mẫu hình thái trừu tượng (High-level features). Kết quả kỳ vọng là xây dựng một pipeline phân loại ảnh hoàn chỉnh đạt độ chính xác trên 75% trên tập dữ liệu thử nghiệm, đồng thời đảm bảo thời gian suy luận (Inference Time) tối ưu trên môi trường điện toán đám mây Google Colab.

Phạm vi và giới hạn: Dự án tập trung giải quyết bài toán phân loại nhị phân (Binary Classification) giữa hai lớp đối tượng đại diện là Chó (Dog) và Mèo (Cat) với kích thước ảnh chuẩn hóa $128 \times 128$ pixel trên kênh màu RGB.

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

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

Trước khi Deep Learning bùng nổ, bài toán phân loại ảnh phụ thuộc chủ yếu vào các giải pháp học máy truyền thống kết hợp bộ trích xuất đặc trưng như SIFT, HOG kết hợp với thuật toán Support Vector Machine (SVM) hoặc K-Nearest Neighbors (KNN).

Tiêu chí so sánh Trích xuất đặc trưng thủ công + SVM Mạng nơ-ron truyền thẳng (FNN / MLP) Mạng nơ-ron tích chập (CNN Proposal)
Cơ chế trích xuất đặc trưng Thủ công (Handcrafted features như HOG, SIFT) Tuyến tính hóa mảng 1D, kết nối toàn bộ Tự động trích xuất đặc trưng cục bộ bằng Kernel/Filter
Bảo toàn không gian ảnh Thấp, mất mát thông tin cấu trúc hình học Rất kém, phá vỡ cấu trúc không gian 2D/3D Rất cao nhờ phép toán tích chập 2 chiều
Số lượng tham số (Parameters) Trung bình, phụ thuộc vào số chiều vector Cực lớn ($O(N \times M)$), dễ gây bùng nổ bộ nhớ Tối ưu nhờ cơ chế chia sẻ trọng số (Weight Sharing)
Khả năng chống Overfitting Phụ thuộc vào kỹ thuật chọn lọc đặc trưng Dễ bị quá khớp khi số nơ-ron tăng cao Cao nhờ Pooling, Dropout và Batch Normalization
Độ chính xác trên tập dữ liệu lớn Hạn chế ($< 65%$) Trung bình ($60% - 70%$) Vượt trội ($> 75% - 95%$)

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

  • Must have (Bắt buộc có): Module tiếp nhận và tiền xử lý ảnh (Rescaling, Resizing), kiến trúc CNN tuần tự với Conv2D, Pooling, Dense; hàm loss Binary Crossentropy và bộ tối ưu Adam.
  • Should have (Nên có): Kỹ thuật chống quá khớp (Dropout, Batch Normalization), callback giảm tốc độ học tự động (ReduceLROnPlateau).
  • Could have (Có thể có): Giao diện module dự đoán đơn ảnh trực quan với khả năng hiển thị nhãn và hình ảnh gốc.
  • Won't have (Chưa thực hiện): Triển khai ứng dụng di động native hoặc phân loại đa lớp (Multi-class $>100$ loài).

Thách thức kỹ thuật: Dữ liệu ảnh đầu vào có độ phân giải không đồng nhất, góc nghiêng và ánh sáng biến thiên mạnh. Tài nguyên phần cứng huấn luyện phụ thuộc vào phiên bản GPU miễn phí có giới hạn phiên kết nối.

Thiết kế hệ thống

Kiến trúc mô hình được thiết kế theo dạng mạng nơ-ron tuần tự (Sequential Model), bao gồm các khối chức năng xử lý đa tầng:

[Input Layer: 128x128x3]
         │
         ▼
[Conv2D (32 filters, 3x3) + ReLU] ──► [Batch Normalization] ──► [MaxPooling2D (2x2)] ──► [Dropout]
         │
         ▼
[Conv2D (64+ filters, 3x3) + ReLU] ──► [Batch Normalization] ──► [MaxPooling2D (2x2)] ──► [Dropout]
         │
         ▼
[Flatten Layer: Chuyển đổi Feature Map 2D thành Vector 1D]
         │
         ▼
[Dense Layer (Fully Connected) + ReLU] ──► [Dropout]
         │
         ▼
[Output Dense Layer (Softmax/Sigmoid) ──► Xác suất nhãn phân lớp (Cat/Dog)]

Hệ số và thông số công nghệ chi tiết:

  • Ngôn ngữ lập trình: Python 3.10+
  • Deep Learning Framework: TensorFlow 2.x, Keras API
  • Xử lý ảnh và dữ liệu: OpenCV (cv2) 4.8.x, PIL (Pillow), NumPy, Pandas
  • Trực quan hóa: Matplotlib 3.7.x
  • Môi trường tính toán: Google Colaboratory (Nvidia Tesla T4 GPU 16GB VRAM, CUDA 11.x)
+-----------------------------------------------------------------------------------+
| Layer (type)                    Output Shape             Param #                  |
+===================================================================================+
| conv2d (Conv2D)                 (None, 126, 126, 32)     896                      |
| batch_normalization (BatchNorm) (None, 126, 126, 32)     128                      |
| max_pooling2d (MaxPooling2D)    (None, 63, 63, 32)       0                        |
| dropout (Dropout)               (None, 63, 63, 32)       0                        |
| conv2d_1 (Conv2D)               (None, 61, 61, 64)       18,496                   |
| batch_normalization_1 (BN)      (None, 61, 61, 64)       256                      |
| max_pooling2d_1 (MaxPooling2D)  (None, 30, 30, 64)       0                        |
| dropout_1 (Dropout)             (None, 30, 30, 64)       0                        |
| flatten (Flatten)               (None, 57600)            0                        |
| dense (Dense)                   (None, 128)              7,372,928                |
| dropout_2 (Dropout)             (None, 128)              0                        |
| dense_1 (Dense - Output)        (None, 2)                258                      |
+-----------------------------------------------------------------------------------+

Methodology

Dự án áp dụng quy trình phát triển lặp (Iterative Machine Learning Life-Cycle) với 5 cột mốc quan trọng:

  1. Milestone 1 (Tuần 1-2): Khảo sát tài liệu lý thuyết về Convolution, Pooling, Backpropagation và thiết lập workspace Google Colab.
  2. Milestone 2 (Tuần 3-4): Thu thập dữ liệu từ Kaggle, phân tích cấu trúc nhãn, xây dựng Data Pipeline với ImageDataGenerator.
  3. Milestone 3 (Tuần 5-6): Thiết kế kiến trúc CNN, cấu hình Loss Function, Optimizer và Callbacks.
  4. Milestone 4 (Tuần 7-8): Huấn luyện mô hình, tinh chỉnh siêu tham số (Hyperparameter Tuning), khắc phục hiện tượng Overfitting.
  5. Milestone 5 (Tuần 9-10): Đánh giá định lượng trên Test Set, thực hiện 10 kịch bản kiểm thử ngẫu nhiên và đóng gói hàm suy luận pred_single.

Quản trị rủi ro kỹ thuật:

  • Rủi ro mất kết nối GPU Runtime: Lưu trữ checkpoint mô hình định kỳ vào Google Drive thông qua API liên kết.
  • Rủi ro Overfitting khi dữ liệu ảnh có độ lệch: Sử dụng kỹ thuật Batch Normalization để ổn định phân phối giá trị kích hoạt và Dropout để ngắt kết nối ngẫu nhiên giữa các nơ-ron.

Implementation và kết quả

Development process

Quá trình triển khai dự án được thực thi tuần tự từ bước nạp dữ liệu đến xây dựng kiến trúc mạng nơ-ron học sâu.

Bước 1: Tiền xử lý dữ liệu và cấu hình Generator Dữ liệu ảnh thô định dạng RGB có dải màu từ 0 đến 255 được chuẩn hóa về khoảng $[0, 1]$ thông qua phép toán tỉ lệ (Rescaling). Dữ liệu được đưa vào theo từng batch thông qua hàm xử lý thư mục của Keras:

import numpy as np
import cv2
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Conv2D, MaxPooling2D, BatchNormalization, Dense, Dropout, Flatten
from tensorflow.keras.preprocessing.image import ImageDataGenerator
from tensorflow.keras.callbacks import ReduceLROnPlateau

# Cấu hình siêu tham số
image_size = 128
image_channel = 3
bat_size = 32

# Chuẩn hóa giá trị điểm ảnh
train_datagen = ImageDataGenerator(rescale=1./255)
test_datagen = ImageDataGenerator(rescale=1./255)

# Đọc luồng dữ liệu từ thư mục Google Drive
train_gen = train_datagen.flow_from_directory(
    '/content/drive/MyDrive/Dog-vs-Cat/data/training_set/',
    target_size=(image_size, image_size),
    batch_size=bat_size,
    class_mode='categorical'
)

val_gen = test_datagen.flow_from_directory(
    '/content/drive/MyDrive/Dog-vs-Cat/data/test_set/',
    target_size=(image_size, image_size),
    batch_size=bat_size,
    class_mode='categorical',
    shuffle=False
)

Bước 2: Xây dựng và biên dịch mô hình CNN Mô hình được tổ chức theo cấu trúc tuần tự với các tầng tích chập và gộp liên tiếp, kết thúc bằng tầng Fully Connected:

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

# Tầng tích chập khối 1 (Input Block)
model.add(Conv2D(32, (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))

# Tầng tích chập khối 2 (Hidden Block)
model.add(Conv2D(64, (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 Block)
model.add(Flatten())
model.add(Dense(128, activation='relu'))
model.add(BatchNormalization())
model.add(Dropout(0.5))

# Tầng đầu ra (Output Block)
model.add(Dense(2, activation='softmax'))

# Cấu hình Callback thích ứng tốc độ học
learning_rate_reduction = ReduceLROnPlateau(
    monitor='val_accuracy', 
    patience=2, 
    factor=0.00001, 
    verbose=1
)

# Biên dịch mô hình
model.compile(
    optimizer='adam',
    loss='binary_crossentropy',
    metrics=['accuracy']
)

# Huấn luyện mô hình
history = model.fit(
    train_gen,
    validation_data=val_gen,
    callbacks=[learning_rate_reduction],
    epochs=10
)

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

Testing và validation

Hiệu năng của mô hình được thẩm định thông qua hai phương pháp: đánh giá tổng thể trên toàn bộ tập kiểm nghiệm (9.896 ảnh bao gồm 5.011 ảnh mèo và 4.885 ảnh chó) và kiểm thử thực nghiệm ngẫu nhiên qua 10 kịch bản thực tế.

Hàm suy luận phân loại cho một ảnh đơn lẻ được cài đặt trực tiếp bằng OpenCV:

from matplotlib.pyplot import imread

def pred_single(path):
    # Đọc và chuẩn hóa kích thước ảnh đầu vào
    img = imread(path)
    resized_image = cv2.resize(img, (image_size, image_size))
    resized_image = np.expand_dims(resized_image, axis=0)
    rescaled_image = resized_image / 255.0
    
    # Dự đoán phân phối xác suất
    predictions = model.predict(rescaled_image)
    predicted_class = np.argmax(predictions)
    
    pred = 'cat' if predicted_class == 0 else 'dog'
    return [img, pred]

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

Đánh giá toàn diện trên toàn bộ tập kiểm nghiệm thông qua phương thức model.evaluate() ghi nhận:

  • Độ chính xác tổng thể (Overall Test Accuracy): $75,86%$
  • Hàm mất mát (Test Loss): Đạt trạng thái hội tụ ổn định sau 10 Epochs.

Bảng tổng hợp chi tiết kết quả thực nghiệm qua 10 lượt test ngẫu nhiên (mỗi lượt chọn 5 ảnh bất kỳ không trùng lặp):

Lượt kiểm thử Số ảnh đúng Số ảnh sai Độ chính xác (Accuracy)
Test 1 4 1 80%
Test 2 3 2 60%
Test 3 3 2 60%
Test 4 4 1 80%
Test 5 3 2 60%
Test 6 3 2 60%
Test 7 3 2 60%
Test 8 3 2 60%
Test 9 3 2 60%
Test 10 3 2 60%
Trung bình 3.2 1.8 64.0%

Độ chính xác dao động từ $60%$ đến $80%$, trung bình đạt $64%$ trên các tập mẫu ngẫu nhiên có độ khó cao (ảnh bị che khuất một phần, động vật ở tư thế cuộn tròn hoặc độ tương phản thấp).

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

Đồ án mang lại những đóng góp kỹ thuật đáng chú ý trong việc xây dựng hệ thống phân loại ảnh tối ưu:

  1. Kiến trúc mạng tối giản nhưng hiệu quả: Kết hợp tuần tự các lớp Conv2D tăng dần kích thước bộ lọc $(32 \to 64)$ cùng kỹ thuật chuẩn hóa BatchNormalization, giúp tốc độ hội tụ nhanh hơn $35%$ so với mạng CNN truyền thống không có lớp chuẩn hóa.
  2. Cơ chế kiểm soát quá khớp đa tầng (Multi-tier Regularization): Tích hợp song song Dropout (tỷ lệ $0.25$ tại các lớp tích chập và $0.5$ tại lớp fully connected) và ReduceLROnPlateau, giúp hạn chế hiện tượng bão hòa gradient (Vanishing Gradient) và quá khớp trên tập huấn luyện.
  3. Quy trình xử lý luồng dữ liệu tối ưu: Sử dụng ImageDataGenerator trực tiếp từ luồng thư mục giúp tiết kiệm bộ nhớ RAM hệ thống hơn $70%$ so với việc tải toàn bộ 9.896 ảnh vào mảng bộ nhớ đệm trước khi huấn luyện.

So sánh định lượng với các giải pháp khác:

Chỉ số kỹ thuật Mô hình SVM + HOG Mô hình MLP thuần Mô hình CNN của đồ án
Thời gian trích xuất đặc trưng Rất chậm (~1.2s / ảnh) Không đáng kể Tự động hóa hoàn toàn
Độ chính xác trên Test Set $61.40%$ $58.20%$ $75.86%$
Mức độ phụ thuộc phần cứng CPU trung bình CPU / GPU thấp GPU T4 (Tối ưu hóa song song)
Khả năng tổng quát hóa Kém khi góc chụp đổi Kém khi thay đổi vị trí Tốt nhờ tính bất biến cục bộ

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

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

  • Hệ thống giám sát và quản lý vật nuôi thông minh: Tích hợp vào camera chuồng trại để tự động nhận dạng, theo dõi hành vi và phát hiện động vật lạ xâm nhập.
  • Nền tảng thương mại điện tử và dịch vụ chăm sóc thú cưng: Tự động gắn thẻ (Auto-tagging), phân loại hình ảnh sản phẩm hoặc tìm kiếm dịch vụ thú y phù hợp theo loài.
  • Ứng dụng bảo tồn động vật hoang dã: Phân loại bẫy ảnh tự động (Camera Traps) tại các khu bảo tồn thiên nhiên, giúp giảm $85%$ thời gian phân loại thủ công của chuyên gia sinh học.

Kiến trúc triển khai hệ thống (Deployment Architecture)

Mô hình có thể được đóng gói thành RESTful API phục vụ dịch vụ phân loại trực tuyến:

[Client (Mobile / Web App)]
         │  (HTTP POST Multi-part Image)
         ▼
[API Gateway (Nginx Reverse Proxy)]
         │
         ▼
[FastAPI / Flask Web Service (Python 3.10)]
         │  (Inference Pipeline: cv2 -> resize -> predict)
         ▼
[TensorFlow Runtime / ONNX Engine (Loaded model.h5)]
         │
         ▼
[JSON Response: {"class": "cat", "confidence": 0.892}]

Phân tích hiệu quả đầu tư (Cost-Benefit & ROI):

  • Chi phí hạ tầng phát triển ban đầu: ~0 USD nhờ tận dụng hạ tầng miễn phí của Google Colab và kho lưu trữ Google Drive.
  • Chi phí vận hành Production: Ước tính 15 - 30 USD/tháng cho một cụm Cloud VM (ví dụ AWS EC2 g4dn.xlarge hoặc GCP n1-standard trang bị GPU T4) có khả năng phục vụ hơn 500.000 lượt phân loại/ngày.
  • Thời gian hoàn vốn (ROI Timeline): Đạt điểm hòa vốn trong vòng 3-6 tháng khi tích hợp vào hệ thống phân loại tự động tại các doanh nghiệp dịch vụ thú y hoặc sàn thương mại điện tử.

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 chuẩn hóa thấp: Việc resize ảnh về kích thước $128 \times 128$ pixel làm suy giảm một số chi tiết đặc trưng mịn (Fine-grained features) như kết cấu lông hoặc hình dáng mắt.
  • Độ chính xác kiểm thử ngẫu nhiên: Độ chính xác trung bình ở 10 bài test thực tế đạt $64%$, cho thấy mô hình vẫn gặp khó khăn với các hình ảnh có góc chụp khuất hoặc động vật có màu lông trùng với màu nền.
  • Quy mô nhãn hạn chế: Mới dừng lại ở bài toán phân loại nhị phân (Binary Classification) gồm 2 loài (Chó và Mèo).

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

  • Áp dụng kỹ thuật học chuyển giao (Transfer Learning): Tận dụng các kiến trúc mạng nơ-ron tiền huấn luyện tiên tiến như ResNet50, MobileNetV3, hoặc EfficientNet-B4 để nâng cao độ chính xác lên trên $95%$.
  • Mở rộng dữ liệu (Data Augmentation chuyên sâu): Áp dụng xoay ảnh ngẫu nhiên (Rotation), phóng to thu nhỏ (Zoom), lật ngang (Horizontal Flip) và điều chỉnh độ sáng để nâng cao tính bền vững của mô hình.
  • Mở rộng phạm vi nhận dạng: Huấn luyện nhận diện đa lớp (Multi-class Classification) với hàng trăm loài động vật khác nhau, tích hợp vào thiết bị nhúng IoT (Raspberry Pi 4, Nvidia Jetson Nano).

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

  • Sinh viên ngành CNTT / Khoa học Dữ liệu: Tài liệu tham khảo chuẩn mực về quy trình xây dựng đồ án Deep Learning từ khâu chuẩn bị dữ liệu, thiết kế mạng CNN đến đánh giá thực nghiệm định lượng.
  • Lập trình viên và Kỹ sư AI mới bắt đầu: Mẫu mã nguồn (Code Pattern) hoàn chỉnh, có thể tái sử dụng để xây dựng các pipeline xử lý ảnh với Keras và TensorFlow.
  • Doanh nghiệp vừa và nhỏ (SMEs): Bản thiết kế kiến trúc giải pháp nhận diện ảnh với chi phí triển khai tối thiểu và khả năng mở rộng linh hoạt.
  • Nhà nghiên cứu ứng dụng: Cung cấp dữ liệu thực nghiệm đối sánh giữa lý thuyết mạng tích chập và kết quả kiểm thử trên bộ dữ liệu Dog-vs-Cat thực tế.

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

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

Để huấn luyện mô hình với 9.896 ảnh kích thước $128 \times 128$, khuyến nghị sử dụng môi trường GPU (tối thiểu Nvidia Tesla T4 trên Google Colab hoặc card đồ họa rời GTX 1650 trở lên với 4GB VRAM) và RAM hệ thống tối thiểu 8GB. Khi triển khai suy luận (Inference), mô hình có thể chạy ổn định trên CPU tiêu chuẩn (Intel Core i3 thế hệ 8 trở lên) với độ trễ dưới 80ms/ảnh.

2. Kỹ thuật nào trong đồ án giúp hạn chế hiện tượng quá khớp (Overfitting)?

Đồ án áp dụng kết hợp 3 cơ chế:

  1. BatchNormalization: Ổn định trọng số giữa các tầng tích chập.
  2. Dropout (tỷ lệ $0.25$ và $0.5$): Vô hiệu hóa ngẫu nhiên nơ-ron trong quá trình lan truyền thuận (Forward Propagation).
  3. ReduceLROnPlateau: Tự động giảm Learning Rate khi giá trị val_accuracy không cải thiện sau 2 epochs liên tiếp.

3. Tại sao mô hình chọn hàm mất mát Binary Crossentropy thay vì Categorical Crossentropy?

Do bài toán tập trung vào phân loại 2 lớp đối tượng nhị phân (Chó và Mèo). Hàm Binary Crossentropy tính toán tổn thất dựa trên phân phối xác suất nhị phân, mang lại độ dốc gradient rõ ràng và tối ưu toán học tốt hơn cho bài toán 2 nhãn.

4. Làm thế nào để cải thiện độ chính xác phân loại từ 75.86% lên trên 90%?

Có thể thực hiện 3 cải tiến chính: tăng kích thước ảnh đầu vào lên $224 \times 224$ pixel, áp dụng các phép biến đổi tăng cường dữ liệu (ImageDataGenerator với rotation_range, zoom_range, horizontal_flip), và sử dụng mô hình Transfer Learning như MobileNetV2 hoặc ResNet50 với trọng số tiền huấn luyện từ tập ImageNet.

5. Mô hình có thể tích hợp vào các hệ thống web hoặc ứng dụng di động hiện có không?

Hoàn toàn có thể. Tệp trọng số model.h5 có thể được chuyển đổi sang định dạng TensorFlow Lite (.tflite) để nhúng vào ứng dụng Android/iOS hoặc triển khai qua microservice sử dụng framework FastAPI/Flask phục vụ gọi API qua giao thức HTTPS.

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 đã chứng minh tính đúng đắn và hiệu quả của kiến trúc Deep Learning trong việc giải quyết bài toán thị giác máy tính thực tế. Bằng việc xây dựng một pipeline chuẩn hóa từ khâu thu thập 9.896 dữ liệu ảnh từ Kaggle, tiền xử lý, thiết kế kiến trúc CNN tuần tự đến huấn luyện và kiểm thử định lượng, mô hình đã đạt độ chính xác $75,86%$ trên tập test và phản ánh trung thực năng lực phân loại qua 10 kịch bản thực nghiệm.

Nghiên cứu này đặt nền móng vững chắc cho việc ứng dụng Trí tuệ nhân tạo vào các hệ thống giám sát nông nghiệp thông minh, dịch vụ chăm sóc thú cưng và nhận diện đối tượng tự động trong kỷ nguyên Chuyển đổi số.