Giới thiệu dự án

Trong bối cảnh nền nông nghiệp 4.0 đang phát triển mạnh mẽ, việc ứng dụng thị giác máy tính (Computer Vision) và trí tuệ nhân tạo (Artificial Intelligence - AI) vào giám sát tự động sinh trưởng cây trồng trở thành xu thế tất yếu. Theo các báo cáo nông nghiệp công nghệ cao, chi phí nhân công cho việc theo dõi, đo đếm thủ công các chỉ số sinh thái chiếm tới 25–35% tổng chi phí vận hành tại các nhà màng hiện đại. Trong đó, dưa chuột (Cucumis sativus) là loại cây trồng ngắn ngày có tốc độ phân cành và đâm lá rất nhanh; số lượng lá và kích thước tán lá là chỉ số quan trọng phản ánh trực tiếp sức khỏe cây, khả năng quang hợp và dự báo năng suất vụ mùa.

Phương pháp truyền thống hiện nay tại hầu hết các trang trại vẫn là kiểm đếm thủ công bằng mắt thường hoặc sử dụng thước đo cơ học. Cách tiếp cận này bộc lộ rõ các điểm nghẽn kỹ thuật:

  • Tốn nhiều thời gian và nhân lực: Không thể áp dụng trên quy mô lớn hàng nghìn cá thể cây trong nhà kính.
  • Độ trễ thông tin cao: Dữ liệu thu thập ngắt quãng, không phản ánh kịp thời các biến động sinh lý do sâu bệnh hay thiếu hụt dinh dưỡng.
  • Sai số chủ quan lớn: Hiện tượng lá xếp chồng (leaf occlusion), biến đổi góc nghiêng và điều kiện ánh sáng tự nhiên dễ dẫn đến đếm sót hoặc đếm trùng.

Đề tài tốt nghiệp "Ứng dụng trí tuệ nhân tạo để phát hiện và xác định số lá cây dưa chuột" do sinh viên Trần Ngọc Ly thực hiện dưới sự hướng dẫn của ThS. Ngô Quang Ước (Khoa Cơ - Điện, Học viện Nông nghiệp Việt Nam) tập trung giải quyết triệt để bài toán trên.

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

  1. Xây dựng và chuẩn hóa bộ dữ liệu hình ảnh cây dưa chuột trong điều kiện thực tế với các góc chụp đa dạng.
  2. Thiết kế, tối ưu hóa mô hình học sâu (Deep Learning) dựa trên thuật toán mạng nơ-ron tích chập (Convolutional Neural Network - CNN) một giai đoạn YOLOv4-tiny.
  3. Đóng gói và triển khai (deployment) hệ thống xử lý thị giác máy tính nhúng trên phần cứng biên Raspberry Pi 4 kết hợp với Camera Module.
  4. Tự động hóa hoàn toàn quy trình phát hiện, khoanh vùng (Bounding Box) và đếm chính xác số lượng lá cây dưa chuột theo thời gian thực (real-time).

Hệ thống kỳ vọng đạt độ chính xác phát hiện trung bình $mAP@0.5 \ge 90%$, tốc độ xử lý trên vi xử lý nhúng $\ge 12\text{ FPS}$, sai số đếm số lá dưới $5%$ so với thực tế, vận hành ổn định trong môi trường nhà kính nông nghiệp với chi phí phần cứng tối ưu dưới $100\text{ USD}$.

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

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

Để định hình giải pháp tối ưu, các phương pháp nhận diện và phân tích ảnh nông nghiệp hiện nay được tổng hợp và đánh giá qua bảng so sánh kỹ thuật:

Tiêu chí Đo đếm thủ công Xử lý ảnh truyền thống (Otsu / Canny) Faster R-CNN (Two-stage) YOLOv4-tiny (One-stage) (Đề xuất)
Độ chính xác ($mAP$) Phụ thuộc con người $50 - 65%$ (kém khi lá đè nhau) $93 - 96%$ $90 - 93%$
Tốc độ xử lý (FPS) Vài phút/cây $5 - 10\text{ FPS}$ $2 - 4\text{ FPS}$ (trên CPU/Edge) $12 - 16\text{ FPS}$ (trên Raspberry Pi 4)
Kích thước mô hình Không áp dụng Thuật toán rời rạc $> 200\text{ MB}$ $\approx 23\text{ MB}$
Chi phí phần cứng Chi phí nhân công cao Thấp Rất cao (yêu cầu GPU rời) Thấp (chạy trên bo mạch ARM)
Khả năng tự động hóa Không Trung bình Cao Rất cao (Real-time Edge AI)

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

  • Must have (Bắt buộc): Nhận diện chính xác lá cây dưa chuột đơn lẻ và các lá đè lấn nhau; thuật toán đếm số lá tự động; chạy mượt mà trên Raspberry Pi 4.
  • Should have (Nên có): Giao diện quan sát trực quan qua VNC Viewer; xuất tọa độ tâm và kích thước hộp giới hạn để hỗ trợ phân tích độ phủ tán lá.
  • Could have (Có thể mở rộng): Đo diện tích tương đối của từng phiến lá; tích hợp cảm biến nhiệt độ, độ ẩm môi trường.
  • Won't have (Chưa thực hiện): Nhận diện phân loại từng loại sâu bệnh hại chuyên sâu trên mặt lá; điều khiển cơ cấu chấp hành thu hoạch tự động.

Thiết kế hệ thống

Kiến trúc giải pháp được thiết kế theo luồng dữ liệu khép kín từ tầng cảm biến hình ảnh đến tầng xử lý suy luận (Inference Engine):

+--------------------------+
| Raspberry Pi Camera Mod  | (Thu thập khung hình 1080p/720p)
+-------------+------------+
              |
              v
+--------------------------+
| Image Preprocessing      | (Resize 416x416, Chuẩn hóa ma trận RGB, Padding)
+-------------+------------+
              |
              v
+--------------------------+
| YOLOv4-tiny Inference    | (Darknet / OpenCV DNN Engine trên BCM2711)
+-------------+------------+
              |
              v
+--------------------------+
| Post-processing (NMS)    | (Lọc ngưỡng Confidence > 0.5, IoU Threshold = 0.4)
+-------------+------------+
              |
              v
+--------------------------+
| Counting & Visualization | (Vẽ BBox, đếm tổng số lá, hiển thị VNC/Monitor)
+--------------------------+

Technology Stack chi tiết của hệ thống:

  • Framework huấn luyện: Darknet Core C/CUDA trên môi trường Google Colab (GPU NVIDIA Tesla T4 16GB).
  • Ngôn ngữ lập trình: Python 3.8.10.
  • Thư viện thị giác máy tính: OpenCV 4.5.3 (tích hợp module dnn).
  • Phần cứng xử lý biên: Raspberry Pi 4 Model B (SoC Broadcom BCM2711 Quad-core Cortex-A72 64-bit @ 1.5GHz, 4GB LPDDR4 SDRAM).
  • Cảm biến hình ảnh: Raspberry Pi Camera Module v2 (Cảm biến 8MP Sony IMX219, tiêu cự cố định, giao tiếp MIPI-CSI).
  • Hệ điều hành nhúng: Raspberry Pi OS (32-bit Debian-based kernel).
  • Giao thức điều khiển từ xa: VNC (Virtual Network Computing) qua mạng LAN/Wi-Fi chuẩn IEEE 802.11ac.

Cấu trúc lưu trữ dữ liệu huấn luyện:

dataset/
├── obj.data           # Cấu hình đường dẫn classes, train, valid, names, backup
├── obj.names          # Nhãn lớp đối tượng (leaf)
├── train.txt          # Danh sách đường dẫn ảnh huấn luyện
├── val.txt            # Danh sách đường dẫn ảnh kiểm thử
└── obj/               # Chứa file .jpg và file nhãn .txt tương ứng (YOLO format)
    ├── leaf_0001.jpg
    ├── leaf_0001.txt  # <class_id> <x_center> <y_center> <width> <height>
    └── ...

Methodology

Dự án áp dụng phương pháp nghiên cứu thực nghiệm kết hợp quy trình phát triển lặp (Iterative Engineering Process):

  1. Thu thập và tiền xử lý dữ liệu: Chụp ảnh thực địa cây dưa chuột ở các giai đoạn từ 3 đến 8 lá. Gán nhãn thủ công với công cụ LabelImg theo định dạng chuẩn YOLO. Áp dụng các kỹ thuật tăng cường dữ liệu (Data Augmentation) gồm xoay ảnh, lật ngang (Horizontal Flip), biến đổi độ sáng và độ bão hòa màu sắc để mô phỏng sự thay đổi thời tiết.
  2. Huấn luyện và tối ưu siêu tham số: Tinh chỉnh các tham số mạng nơ-ron (learning rate, momentum, decay, anchor boxes) trên nền tảng đám mây.
  3. Chuyển giao và triển khai phần cứng: Tối ưu hóa mô hình sang dạng weights nhị phân gọn nhẹ, tích hợp vào pipeline đọc luồng video trực tiếp từ camera CSI bằng OpenCV.
  4. Kiểm thử và đánh giá: Đo đạc các chỉ số $Precision$, $Recall$, $mAP$, độ trễ suy luận (latency) và nhiệt độ vận hành phần cứng trong điều kiện thực tế.

Implementation và kết quả

Development process

Mô hình học sâu sử dụng kiến trúc mạng YOLOv4-tiny. Kiến trúc này rút gọn số tầng tích chập (Convolutional Layers) và sử dụng cấu trúc CSPOS (Cross Stage Partial connections) nhằm giảm khối lượng tính toán FLOPs, cho phép thực thi thời gian thực trên vi xử lý ARM.

Để tùy biến mạng cho 1 lớp đối tượng duy nhất (leaf), số lượng bộ lọc (filters) tại các tầng tích chập ngay trước mỗi tầng [yolo] được tính toán theo công thức chuẩn: $$\text{filters} = (\text{classes} + 5) \times 3 = (1 + 5) \times 3 = 18$$

Đoạn cấu hình tham số trong tệp yolov4-tiny-custom.cfg:

[net]
batch=64
subdivisions=16
width=416
height=416
channels=3
momentum=0.9
decay=0.0005
learning_rate=0.00261
max_batches=4000
policy=steps
steps=3200,3600
scales=.1,.1

# Cấu hình tầng tích chập trước YOLO Layer thứ nhất
[convolutional]
size=1
stride=1
pad=1
filters=18
activation=linear

[yolo]
mask = 3,4,5
anchors = 10,14,  23,27,  37,58,  81,82,  135,169,  344,319
classes=1
num=6
jitter=.3
scale_x_y = 1.05
cls_normalizer=1.0
iou_normalizer=0.07
iou_loss=ciou
nms_kind=greedynms
beta_nms=0.6

Mã nguồn Python thực thi suy luận và đếm số lá trên Raspberry Pi 4 thông qua OpenCV DNN:

import cv2
import numpy as np

def detect_and_count_leaves(weights_path, config_path, conf_thresh=0.5, nms_thresh=0.4):
    # Khởi tạo mạng nơ-ron từ file weights và config
    net = cv2.dnn.readNetFromDarknet(config_path, weights_path)
    net.setPreferableBackend(cv2.dnn.DNN_BACKEND_OPENCV)
    net.setPreferableTarget(cv2.dnn.DNN_TARGET_CPU)

    layer_names = net.getLayerNames()
    output_layers = [layer_names[i - 1] for i in net.getUnconnectedOutLayers()]

    # Khởi tạo Camera CSI trên Raspberry Pi
    cap = cv2.VideoCapture(0)
    cap.set(cv2.CAP_PROP_FRAME_WIDTH, 640)
    cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 480)

    while cap.isOpened():
        ret, frame = cap.read()
        if not ret:
            break

        height, width = frame.shape[:2]
        # Chuyển đổi khung hình sang blob chuẩn 416x416
        blob = cv2.dnn.blobFromImage(frame, 1/255.0, (416, 416), swapRB=True, crop=False)
        net.setInput(blob)
        outs = net.forward(output_layers)

        boxes = []
        confidences = []

        for out in outs:
            for detection in out:
                scores = detection[5:]
                class_id = np.argmax(scores)
                confidence = scores[class_id]
                if confidence > conf_thresh:
                    # Tính toán tọa độ Bounding Box
                    center_x = int(detection[0] * width)
                    center_y = int(detection[1] * height)
                    w = int(detection[2] * width)
                    h = int(detection[3] * height)
                    x = int(center_x - w / 2)
                    y = int(center_y - h / 2)

                    boxes.append([x, y, w, h])
                    confidences.append(float(confidence))

        # Áp dụng Non-Maximum Suppression (NMS) để loại bỏ các box trùng lặp
        indices = cv2.dnn.NMSBoxes(boxes, confidences, conf_thresh, nms_thresh)
        leaf_count = len(indices)

        if leaf_count > 0:
            for i in indices.flatten():
                x, y, w, h = boxes[i]
                cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 2)
                label = f"Leaf: {confidences[i]:.2f}"
                cv2.putText(frame, label, (x, y - 5), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 1)

        # Hiển thị tổng số lá đếm được
        cv2.putText(frame, f"Total Leaves: {leaf_count}", (20, 40),
                    cv2.FONT_HERSHEY_SIMPLEX, 1.0, (0, 0, 255), 2)

        cv2.imshow("Cucumber Leaf Counting - Raspberry Pi 4", frame)
        if cv2.waitKey(1) & 0xFF == ord('q'):
            break

    cap.release()
    cv2.destroyAllWindows()

if __name__ == "__main__":
    detect_and_count_leaves("backup/yolov4-tiny-custom_best.weights", "yolov4-tiny-custom.cfg")

Testing và validation

Quá trình huấn luyện mô hình được thực hiện qua 4,000 epochs với 1,200 ảnh mẫu (tỷ lệ phân chia tập Train/Validation là 80/20). Quá trình hội tụ của hàm mất mát (Loss function) và độ chính xác được ghi nhận chi tiết:

  • Hội tụ hàm mất mát: Hàm mất mát tổng hợp giảm liên tục từ mức $8.452$ tại vòng lặp thứ 100 xuống mức ổn định $0.214$ tại vòng lặp thứ 3,800.
  • Hiệu năng nhận diện:
    • $Precision$ (Độ chuẩn xác): $91.82%$
    • $Recall$ (Độ bao phủ): $89.56%$
    • $F1\text{-Score}$: $90.68%$
    • $mAP@0.5$: $92.40%$

Đánh giá hiệu năng thực thi phần cứng giữa các nền tảng:

Nền tảng thử nghiệm Môi trường phần cứng Độ trễ suy luận (Inference Latency) Tốc độ xử lý (FPS) Mức tải CPU / GPU
Google Colab NVIDIA Tesla T4 GPU $14.2\text{ ms}$ $70.4\text{ FPS}$ GPU: $42%$
PC Workstation Intel Core i7-10700 CPU $28.5\text{ ms}$ $35.1\text{ FPS}$ CPU: $35%$
Raspberry Pi 4B Quad Cortex-A72 @ 1.5GHz $68.0\text{ ms}$ $14.7\text{ FPS}$ CPU: $88%$ (4 Cores)

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

Hệ thống đã hoàn thành đầy đủ tất cả các tính năng thiết kế ban đầu:

  1. Phát hiện chính xác các phiến lá dưa chuột ngay cả khi có hiện tượng che khuất một phần ($IoU \ge 0.4$).
  2. Số lượng lá đếm tự động đạt độ tương đồng $95.6%$ so với số liệu kiểm đếm thực tế của chuyên gia nông nghiệp (sai số trung bình $< 0.4$ lá/cây).
  3. Hệ thống phần cứng nhúng hoạt động liên tục, ổn định không bị hiện tượng tràn bộ nhớ RAM (mức chiếm dụng RAM hệ thống khoảng $1.1\text{ GB} / 4\text{ GB}$).

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

Dự án mang lại những đóng góp kỹ thuật và ứng dụng thực tiễn nổi bật:

  • Tối ưu hóa kiến trúc mạng cho thiết bị biên: Thay vì sử dụng các mô hình nặng như Faster R-CNN hay SSD VGG-16 đòi hỏi phần cứng GPU đắt tiền, việc tinh chỉnh YOLOv4-tiny giúp giảm kích thước mô hình xuống chỉ còn $\approx 23\text{ MB}$ (giảm hơn $88%$ dung lượng), cho phép nạp toàn bộ trọng số vào bộ nhớ đệm CPU của Raspberry Pi 4 để đạt tốc độ xử lý $14.7\text{ FPS}$.
  • Quy trình gán nhãn và xử lý đè lấn đặc thù: Xây dựng bộ quy tắc gán nhãn chuyên biệt cho phiến lá dưa chuột trong điều kiện tự nhiên, xử lý triệt để hiện tượng lá non nằm đè trên lá già thông qua điều chỉnh thuật toán NMS kết hợp chuẩn đo lường $CIoU\text{ Loss}$.
  • Giải pháp chi phí thấp (Low-cost Edge AI): Toàn bộ hệ thống thu thập và tính toán có chi phí chế tạo dưới $2.500.000\text{ VNĐ}$, mở ra khả năng thương mại hóa và ứng dụng đại trà cho các hợp tác xã nông nghiệp 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ế

  1. Giám sát tự động trong nhà màng thông minh: Lắp đặt hệ thống camera cố định trên giàn treo hoặc robot di chuyển dọc luống cây dưa chuột để tự động quét toàn bộ vườn, ghi nhận số lượng lá theo từng ngày, từ đó lập biểu đồ sinh trưởng sinh khối (Biomass curve).
  2. Chọn lọc cây giống tại vườn ươm: Tự động phân loại các cây con đạt chuẩn xuất vườn (ví dụ: đạt từ 4 đến 5 lá thật khỏe mạnh) mà không cần sự can thiệp thủ công của công nhân.

Hướng dẫn triển khai phần cứng và phần mềm

1. Yêu cầu thiết bị:

  • Bo mạch Raspberry Pi 4 Model B (khuyến nghị bản 4GB hoặc 8GB RAM).
  • Bộ tản nhiệt quạt làm mát chủ động kèm vỏ nhôm (tránh hiện tượng giảm xung do nhiệt độ cao).
  • Module Camera Raspberry Pi v2 (gắn cáp dẹt 15-pin vào cổng Camera MIPI-CSI).
  • Nguồn điện chuẩn USB-C $5\text{V} - 3\text{A}$.
  • Thẻ nhớ MicroSD tối thiểu 32GB Class 10 (tốc độ đọc $\ge 100\text{MB/s}$).

2. Các bước cấu hình phần mềm:

# Cập nhật hệ điều hành
sudo apt update && sudo apt upgrade -y

# Cài đặt các gói phụ thuộc cho OpenCV và Python
sudo apt install build-essential cmake pkg-config libjpeg-dev libtiff5-dev \
libjasper-dev libpng-dev libavcodec-dev libavformat-dev libswscale-dev \
libv4l-dev libxvidcore-dev libx264-dev libfontconfig1-dev libcairo2-dev \
libgdk-pixbuf2.0-dev libpango1.0-dev libgtk2.0-dev libgtk-3-dev \
libatlas-base-dev gfortran python3-dev python3-pip -y

# Cài đặt OpenCV và NumPy
pip3 install opencv-python==4.5.3.56 numpy==1.20.3

# Kích hoạt cổng Camera CSI
sudo raspi-config
# Chọn: Interface Options -> Legacy Camera -> Enable -> Reboot

Phân tích hiệu quả kinh tế (ROI)

  • Chi phí đầu tư ban đầu: Khoảng $2.500.000\text{ VNĐ}$/bộ thiết bị.
  • Tiết kiệm vận hành: Một trang trại quy mô $1.000\text{ m}^2$ thông thường cần 1 nhân công giám sát 2 giờ/ngày (chi phí khoảng $3.000.000\text{ VNĐ}$/tháng). Khi triển khai hệ thống tự động, chi phí nhân công giảm $80%$, tương đương tiết kiệm $2.400.000\text{ VNĐ}$/tháng.
  • Thời gian hoàn vốn: Chỉ sau khoảng 1.0 đến 1.5 tháng vận hành.

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

Hạn chế kỹ thuật

  • Nghẽn phần cứng khi nhiệt độ cao: Khi hoạt động liên tục trên 4 tiếng trong nhà màng có nhiệt độ môi trường $> 38^\circ\text{C}$, CPU Raspberry Pi 4 có thể bị kích hoạt cơ chế giảm xung nhịp (Thermal Throttling), làm giảm tốc độ xử lý xuống $8 - 10\text{ FPS}$.
  • Góc khuất lá non: Những phiến lá non mới nhú nằm hoàn toàn dưới bóng tán của lá lớn tầng trên có thể bị bỏ sót nếu chỉ sử dụng một góc chụp từ trên xuống (Top-down View).

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

  • Nâng cấp sử dụng camera đo chiều sâu (Depth Camera như Intel RealSense D435) kết hợp mạng phân vùng điểm ảnh (Instance Segmentation - YOLOv8-seg hoặc Mask R-CNN) để tính toán chính xác chỉ số diện tích lá (Leaf Area Index - LAI).
  • Tích hợp thêm bộ tăng tốc phần cứng USB Google Coral Edge TPU hoặc chuyển đổi mô hình sang định dạng TensorFlow Lite / ONNX Runtime để tăng tốc độ suy luận lên $> 30\text{ FPS}$.
  • Phát triển hệ thống truyền dữ liệu không dây qua giao thức MQTT lên máy chủ đám mây, tích hợp Dashboard Web giám sát từ xa cho người nông dân.

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

  • Sinh viên khối ngành Kỹ thuật (Điện tử, Cơ điện tử, Tự động hóa, CNTT): Tiếp cận tài liệu tham khảo hoàn chỉnh về việc tích hợp thuật toán Deep Learning hiện đại vào phần cứng nhúng thực tế, từ khâu xử lý dữ liệu đến khâu tối ưu hóa hệ thống.
  • Kỹ sư và Lập trình viên Computer Vision: Nắm bắt kỹ thuật cấu hình và triển khai mạng YOLO rút gọn trên nền tảng vi xử lý ARM không có GPU rời, hiểu rõ cách tinh chỉnh cấu hình .cfg và tính toán bộ lọc.
  • Chủ trang trại và Doanh nghiệp nông nghiệp công nghệ cao: Sở hữu giải pháp tự động hóa chi phí thấp, dễ dàng nhân rộng để giám sát tình trạng mùa màng, nâng cao năng suất và tối ưu hóa chi phí sản xuất.
  • Nhà nghiên cứu Nông nghiệp số: Có được công cụ thu thập dữ liệu sinh khối thực vật khách quan, chính xác phục vụ các nghiên cứu về di truyền học cây trồng và tác động của phân bón/dinh dưỡng.

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

1. Hệ thống có yêu cầu kết nối Internet liên tục để phát hiện và đếm lá không?

Không. Toàn bộ quá trình tiền xử lý, chạy mô hình học sâu YOLOv4-tiny và thuật toán đếm số lá đều được thực hiện nội bộ (Offline Inference) trực tiếp trên bộ vi xử lý của Raspberry Pi 4. Mạng Internet chỉ cần thiết khi người dùng muốn truy cập giao diện VNC từ xa hoặc đồng bộ dữ liệu lên máy chủ lưu trữ.

2. Nếu cường độ ánh sáng trong nhà kính thay đổi đột ngột giữa trời nắng và trời râm thì độ chính xác có bị giảm không?

Mô hình đã được huấn luyện với tập dữ liệu đa dạng chứa các điều kiện ánh sáng khác nhau kết hợp kỹ thuật tăng cường dữ liệu (Data Augmentation - ngẫu nhiên thay đổi độ sáng, độ bão hòa màu và độ tương phản). Do đó, mô hình duy trì độ ổn định cao, biên độ suy giảm độ chính xác trong điều kiện ánh sáng biến động mạnh không vượt quá $3%$.

3. Tại sao lại lựa chọn YOLOv4-tiny thay vì phiên bản YOLOv4 đầy đủ hoặc YOLOv3?

YOLOv4 đầy đủ có số lượng tham số rất lớn (hơn 64 triệu tham số), đòi hỏi tài nguyên tính toán vượt quá khả năng xử lý của CPU Raspberry Pi 4 (tốc độ sẽ giảm xuống dưới $1\text{ FPS}$, gây treo hệ thống). YOLOv4-tiny chỉ có khoảng 6 triệu tham số, kích thước tệp weights chỉ $\approx 23\text{ MB}$, là điểm cân bằng hoàn hảo giữa độ chính xác ($mAP@0.5 > 92%$) và tốc độ xử lý ($> 14\text{ FPS}$) trên thiết bị biên.

4. Bo mạch Raspberry Pi 4 có gặp hiện tượng quá nhiệt khi chạy mô hình liên tục không?

Nếu không có tản nhiệt, nhiệt độ chip BCM2711 có thể vượt ngưỡng $75^\circ\text{C}$ và kích hoạt giảm xung. Tuy nhiên, khi được trang bị vỏ tản nhiệt nhôm liền khối kết hợp quạt làm mát $5\text{V}$, nhiệt độ CPU luôn duy trì ổn định trong khoảng $48 - 56^\circ\text{C}$, đảm bảo hệ thống vận hành liên tục 24/7.

5. Dự án này có thể áp dụng cho các loại cây trồng khác ngoài cây dưa chuột được không?

Hoàn toàn có thể. Quy trình kỹ thuật và mã nguồn được thiết kế theo cấu trúc module chuẩn hóa. Người dùng chỉ cần thay thế tập dữ liệu ảnh và gán nhãn cho loại cây trồng mới (ví dụ: cà chua, ớt chuông, dâu tây), sau đó tiến hành huấn luyện lại (Retrain) mô hình Darknet là có thể ứng dụng ngay trên hệ thống phần cứng hiện có.

Kết luận

Đề tài "Ứng dụng trí tuệ nhân tạo để phát hiện và xác định số lá cây dưa chuột" đã chứng minh tính khả thi và hiệu quả vượt trội của việc kết hợp thuật toán thị giác máy tính hiện đại với phần cứng nhúng chi phí thấp trong nông nghiệp công nghệ cao. Với độ chính xác phát hiện $mAP@0.5$ đạt $92.4%$ và tốc độ xử lý thời gian thực $14.7\text{ FPS}$ trên Raspberry Pi 4, giải pháp không chỉ giải quyết triệt để bài toán theo dõi sinh trưởng tự động mà còn mở ra tiềm năng ứng dụng rộng rãi trong các hệ thống nhà màng thông minh tại Việt Nam. Đây là nền tảng vững chắc để tiếp tục phát triển các hệ thống robot nông nghiệp tự hành và các giải pháp phenotyping cây trồng thế hệ mới trong tương lai.