Giới thiệu dự án

Trong kỷ nguyên Công nghiệp 4.0, tự động hóa dây chuyền sản xuất đóng vai trò quyết định đến năng suất và chất lượng sản phẩm của các doanh nghiệp. Theo các khảo sát công nghiệp sản xuất, quy trình phân loại sản phẩm thủ công bằng sức người thường tồn tại tỷ lệ sai sót dao động từ 3% đến 7% do mệt mỏi thị giác và thao tác lặp lại, đồng thời chi phí nhân công có xu hướng tăng đều đặn từ 10% đến 15% mỗi năm. Việc áp dụng các giải pháp tự động hóa thông minh giúp chuẩn hóa quy trình, loại bỏ điểm nghẽn năng suất và giảm thiểu tối đa tổn thất do lỗi phân loại.

Các hệ thống phân loại truyền thống thường dựa vào cảm biến cơ quang học, cảm biến tiệm cận hoặc công nghệ xử lý ảnh cổ điển (như tách ngưỡng nhị phân, phát hiện biên cạnh dựa trên hình thái học). Những phương pháp này bộc lộ nhiều điểm hạn chế nghiêm trọng: kém linh hoạt khi sản phẩm thay đổi quy cách, dễ bị ảnh hưởng bởi điều kiện chiếu sáng và không có khả năng phân biệt các đối tượng có hình thái tương đồng nhưng khác biệt về kích thước hoặc chi tiết bề mặt. Đề tài "Ứng dụng công nghệ CNN vào việc phân loại sản phẩm trên băng chuyền" được phát triển nhằm giải quyết triệt để bài toán nhận diện và phân loại sản phẩm tự động, ứng dụng mạng neural tích chập (Convolutional Neural Network - CNN) kết hợp với nền tảng máy tính nhúng giá rẻ Raspberry Pi.

+------------------+      +-------------------+      +----------------------+
|  Camera Pi CSI   | ---> |  Raspberry Pi 3B  | ---> | Module Driver L298N  | ---> Động cơ DC Băng tải
|  Thu nhận ảnh    |      | Inception-v3 CNN  |      +----------------------+
+------------------+      +---------+---------+      +----------------------+
                                    |              | Động cơ Servo MG996  | ---> Cánh gạt phân loại
+------------------+                |              +----------------------+
| Cảm biến quang IR| ---------------+
| Phát hiện vật thể|
+------------------+

Mục tiêu dự án

  1. Nghiên cứu và làm chủ mô hình mạng neural tích chập (CNN): Phân tích sâu kiến trúc các lớp tích chập (Convolutional Layer), hàm kích hoạt phi tuyến ReLU, lớp gộp lấy mẫu (MaxPooling Layer) và lớp kết nối đầy đủ (Fully-Connected Layer).
  2. Ứng dụng kỹ thuật học chuyển tiếp (Transfer Learning): Sử dụng mô hình tiền huấn luyện Inception-v3 của Google để trích xuất đặc trưng nút cổ chai (Bottleneck Features), giúp giảm thiểu thời gian huấn luyện và tối ưu hóa tài nguyên tính toán trên thiết bị nhúng.
  3. Thiết kế và chế tạo phần cứng băng chuyền thực nghiệm: Tích hợp máy tính nhúng Raspberry Pi 3 Model B, module Camera Pi 5MP, module điều khiển động cơ L298N, động cơ servo MG996R kim loại và cảm biến quang hồng ngoại LM393.
  4. Xây dựng chương trình điều khiển tích hợp nhúng: Lập trình hệ thống bằng ngôn ngữ Python để đồng bộ hóa việc đọc cảm biến, kích hoạt chụp ảnh, thực thi mô hình suy luận TensorFlow và điều khiển cơ cấu chấp hành gạt sản phẩm.

Phương pháp tiếp cận và kết quả kỳ vọng

Hệ thống kết hợp giữa phần cứng nhúng biên (Edge Computing) và mô hình học sâu. Thay vì huấn luyện một mạng CNN từ đầu đòi hỏi hàng triệu bức ảnh và cụm máy chủ GPU đắt đỏ, giải pháp áp dụng Transfer Learning trên mạng Inception-v3 với tập dữ liệu tùy biến gồm 650 ảnh chụp thực tế từ Camera Pi.

Hệ thống đặt mục tiêu đạt độ chính xác phân loại trên 90%, thời gian đáp ứng cơ cấu phân loại dưới 500ms kể từ khi phát hiện vật thể, đồng thời duy trì độ ổn định liên tục trong môi trường vận hành mô phỏng công nghiệp. Giới hạn đề tài tập trung vào việc phân loại 2 nhóm kích thước sản phẩm (Hộp to, Hộp nhỏ) và nhận diện trạng thái không có sản phẩm (Empty).

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

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

Trước khi xây dựng hệ thống, các giải pháp phân loại sản phẩm trên thị trường được phân tích và đánh giá qua bảng so sánh kỹ thuật:

Tiêu chí Phân loại thủ công Cảm biến cơ - quang học Xử lý ảnh truyền thống (OpenCV) Deep Learning CNN (Đề tài)
Độ chính xác 92% - 95% (giảm theo thời gian) 85% - 90% 88% - 92% (phụ thuộc ánh sáng) > 95% (ổn định, tự thích nghi)
Tốc độ xử lý Chậm (1 - 2 sản phẩm/s) Rất nhanh (< 50ms) Trung bình (100 - 200ms) Nhanh (~ 350 - 450ms trên RPi 3)
Độ linh hoạt Cao nhưng tốn chi phí đào tạo Kém (phải chỉnh cơ khí/sensor) Trung bình (phải viết lại thuật toán) Rất cao (chỉ cần huấn luyện lại nhãn)
Chi phí đầu tư Chi phí vận hành liên tục cao Thấp Trung bình Thấp - Tối ưu (dưới 2.500.000 VNĐ)
Khả năng mở rộng Giới hạn bởi nhân sự Khó mở rộng đa thuộc tính Hạn chế với sản phẩm biến dạng Dễ dàng mở rộng phân loại đa lớp

Ma trận ưu tiên yêu cầu hệ thống (MoSCoW)

  • Must have (Bắt buộc phải có): Nhận diện chính xác 3 trạng thái (Hộp to, Hộp nhỏ, Empty); điều khiển động cơ DC chạy/dừng băng tải qua module L298N; điều khiển cánh gạt Servo MG996 quay đúng góc 90 độ khi phát hiện hộp cần phân loại; cảm biến hồng ngoại kích hoạt ngắt chụp ảnh chính xác.
  • Should have (Nên có): Tối ưu hóa thời gian suy luận (Inference Latency) trên CPU ARM của Raspberry Pi dưới 500ms; tự động cân bằng sáng khi chụp qua camera CSI.
  • Could have (Có thể có): Giao diện đồ họa giám sát số lượng sản phẩm theo thời gian thực (GUI/Dashboard).
  • Won't have (Chưa thực hiện trong giai đoạn này): Khả năng phân loại đồng thời hàng chục loại quy cách sản phẩm phức tạp trên cùng một khung hình.

Thiết kế hệ thống

Kiến trúc hệ thống được xây dựng theo mô hình điều khiển phân tầng, lấy máy tính nhúng Raspberry Pi 3 làm hạt nhân tính toán trung tâm.

graph TD
    subgraph "Khối Cảm Biến & Thu Nhận"
        IR["Cảm Biến Hồng Ngoại LM393"] -->|Tín hiệu logic GPIO| RPI["Bộ Xử Lý Trung Tâm Raspberry Pi 3B"]
        CAM["Raspberry Pi Camera V1 5MP (CSI)"] -->|Khung hình 320x240| RPI
    end

    subgraph "Khối Xử Lý Học Sâu (TensorFlow)"
        RPI --> PRE["Tiền Xử Lý Ảnh"]
        PRE --> INCEP["Inception-v3 Graph (retrained_graph.pb)"]
        INCEP --> BOT["Bottleneck Vector (2048 dims)"]
        BOT --> FC["Lớp Softmax Phân Loại"]
        FC --> DEC{"Quyết Định Nhãn"}
    end

    subgraph "Khối Chấp Hành & Cơ Khí"
        DEC -->|Hộp Nhỏ / Không Gạt| L298N["Module Cầu H L298N"]
        DEC -->|Hộp To / Gạt 90°| SERVO["Động Cơ Servo MG996"]
        L298N --> DC["Động Cơ DC Giảm Tốc 12V"]
    end

Thông số kỹ thuật của Technology Stack

  • Bộ xử lý trung tâm: Raspberry Pi 3 Model B, SoC Broadcom BCM2837 (4 nhân ARM Cortex-A53 64-bit @ 1.2 GHz), GPU VideoCore IV, 1 GB LPDDR2 SDRAM.
  • Camera: Raspberry Pi Camera Module V1.3 (Cảm biến 5MP OmniVision OV5647, giao tiếp trực tiếp qua bus CSI-2 tốc độ cao, hỗ trợ ảnh chụp tĩnh lên tới 2592 × 1944 pixels).
  • Mạch điều khiển công suất: Module L298N Dual H-Bridge, điện áp hoạt động logic 5V, điện áp động lực 5V - 12V, dòng cực đại $2\text{A}$ mỗi kênh, tích hợp diode dập xung bảo vệ ngược dòng từ cuộn cảm.
  • Cơ cấu phân loại: Động cơ Servo RC MG996R, điện áp hoạt động $4.8\text{V} - 7.2\text{V}$, moment xoắn $10\text{ kg}\cdot\text{cm}$ tại $4.8\text{V}$, bánh răng hoàn toàn bằng kim loại, điều khiển góc quay bằng phương pháp điều chế độ rộng xung (PWM).
  • Cảm biến phát hiện: Module cảm biến hồng ngoại LM393, bước sóng phát hiện $700\text{nm} - 1\text{mm}$, khoảng cách phát hiện tùy chỉnh bằng biến trở từ $2\text{cm} - 30\text{cm}$, ngõ ra số logic TTL (Mức 0 khi có vật cản, Mức 1 khi không có vật cản).
  • Nền tảng phần mềm: Hệ điều hành Raspbian 8.0 (Debian Jessie); Ngôn ngữ Python 2.7 / 3.4; Thư viện TensorFlow v1.0.0 for ARMv7l; Thư viện điều khiển phần cứng RPi.GPIO.

Cấu trúc dữ liệu và mô hình Tensor

Trong TensorFlow, mọi phép biến đổi đại số tuyến tính đều được biểu diễn thông qua đối tượng Tensor có các thuộc tính:

$$\text{Tensor} \equiv (\text{Rank}, \text{Shape}, \text{Dtype})$$

  • Scalar (Rank 0, Shape ()): Thể hiện giá trị vô hướng.
  • Vector (Rank 1, Shape (N,)): Đại diện cho mảng phân phối xác suất đầu ra từ hàm Softmax.
  • Matrix (Rank 2, Shape (M, N)): Đại diện cho ma trận trọng số $\mathbf{W}$.
  • N-Tensor (Rank 4, Shape (Batch_Size, Height, Width, Channels)): Cấu trúc tensor ảnh đầu vào chuyển đổi thành kiểu dữ liệu tf.float32 hoặc tf.uint8.

Phương pháp nghiên cứu và quy trình huấn luyện

Quy trình phát triển dự án tuân theo mô hình lặp tích hợp (Iterative Integration):

+-------------------+     +--------------------+     +---------------------+
| Thu thập 650 ảnh  | --> | Trích xuất vector  | --> | Huấn luyện Softmax  |
| từ Camera Pi      |     | Bottleneck (2048)  |     | 500 bước lặp (Step) |
+-------------------+     +--------------------+     +---------------------+
                                                                |
+-------------------+     +--------------------+                v
| Triển khai nhúng  | <-- | Xuất đồ thị tĩnh   | <-- +---------------------+
| trên Raspberry Pi |     | retrained_graph.pb |     | Đánh giá Test Set   |
+-------------------+     +--------------------+     | 150 ảnh độc lập     |
                                                     +---------------------+
  1. Khảo sát & Chuẩn bị dữ liệu: Chụp 650 bức ảnh thực tế của các mẫu hộp to, hộp nhỏ và nền băng tải ở nhiều điều kiện góc nghiêng và ánh sáng khác nhau tại độ phân giải chuẩn $320 \times 240$ pixels.
  2. Trích xuất Bottleneck (Bottleneck Extraction): Đưa toàn bộ ảnh qua các tầng tích chập của mô hình Inception-v3 đã được Google huấn luyện sẵn trên tập ImageNet (1.4 triệu ảnh, 1000 lớp). Đầu ra của tầng gộp cuối cùng trước bộ phân loại gốc cho ra một vector đặc trưng 2048 chiều cho mỗi ảnh.
  3. Tái huấn luyện (Retraining): Đóng băng toàn bộ trọng số của các tầng tích chập phía trước, chỉ gắn thêm một tầng Fully-Connected và Softmax mới để phân loại 3 lớp: hop_to, hop_nho, empty. Huấn luyện trong 500 - 1000 bước lặp (steps) với tốc độ học (learning rate) $\eta = 0.01$.
  4. Đóng gói và triển khai: Xuất đồ thị tính toán nhị phân tĩnh retrained_graph.pb và tệp nhãn retrained_labels.txt nạp trực tiếp vào bộ nhớ Raspberry Pi để chạy suy luận offline không cần kết nối Internet.

Implementation và kết quả

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

1. Nguyên lý toán học của mạng CNN trong hệ thống

Mô hình thực hiện chuỗi phép tính tích chập hai chiều liên tiếp:

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

Trong đó:

  • $I$ là ma trận điểm ảnh đầu vào kích thước $H \times W$.
  • $K$ là ma trận bộ lọc hạt nhân (Kernel Filter) kích thước $k \times k$ (thường là $3 \times 3$).
  • $S(i, j)$ là bản đồ đặc trưng thu được (Feature Map).

Sau mỗi lớp tích chập, hàm kích hoạt phi tuyến ReLU (Rectified Linear Unit) được áp dụng nhằm triệt tiêu các giá trị âm, kích thích tính phi tuyến của mạng:

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

Quá trình giảm chiều dữ liệu được thực hiện bởi lớp MaxPooling kích thước cửa sổ trượt $2 \times 2$ với bước nhảy $\text{stride} = 2$:

$$M(i, j) = \max_{p, q \in {0, 1}} S(2i + p, 2j + q)$$

Phép tính này làm giảm kích thước mỗi chiều của ma trận đặc trưng đi 2 lần, giảm số lượng tham số cần tính toán xuống 4 lần, hạn chế hiện tượng quá khớp (Overfitting).

2. Cấu trúc mã nguồn điều khiển và nhận dạng trên Raspberry Pi

Dưới đây là đoạn mã thực thi quy trình điều khiển GPIO, đọc cảm biến và gọi mô hình suy luận phân loại sản phẩm:

# -*- coding: utf-8 -*-
import os
import time
import RPi.GPIO as GPIO
import tensorflow as tf
import numpy as np
from PIL import Image

# Cấu hình chân GPIO trên Raspberry Pi 3B
PIN_IR_SENSOR = 17      # Chân nhận tín hiệu cảm biến hồng ngoại LM393
PIN_MOTOR_IN1 = 27      # Chân điều khiển L298N IN1
PIN_MOTOR_IN2 = 22      # Chân điều khiển L298N IN2
PIN_MOTOR_ENA = 18      # Chân PWM điều khiển tốc độ động cơ DC
PIN_SERVO_PWM = 24      # Chân PWM điều khiển Servo MG996

GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
GPIO.setup(PIN_IR_SENSOR, GPIO.IN)
GPIO.setup([PIN_MOTOR_IN1, PIN_MOTOR_IN2], GPIO.OUT)
GPIO.setup(PIN_MOTOR_ENA, GPIO.OUT)
GPIO.setup(PIN_SERVO_PWM, GPIO.OUT)

# Thiết lập tần số PWM cho Servo (50Hz) và Động cơ (1000Hz)
pwm_servo = GPIO.PWM(PIN_SERVO_PWM, 50)
pwm_motor = GPIO.PWM(PIN_MOTOR_ENA, 1000)
pwm_servo.start(0)
pwm_motor.start(75) # Băng tải chạy với 75% công suất

def set_servo_angle(angle):
    """Điều khiển góc quay Servo MG996 qua chu kỳ xung Duty Cycle"""
    duty = 2.5 + (angle / 18.0)
    pwm_servo.ChangeDutyCycle(duty)
    time.sleep(0.4)
    pwm_servo.ChangeDutyCycle(0)

def load_graph(model_file):
    """Nạp đồ thị tính toán nhị phân đã retrain vào TensorFlow Session"""
    graph = tf.Graph()
    graph_def = tf.GraphDef()
    with open(model_file, "rb") as f:
        graph_def.ParseFromString(f.read())
    with graph.as_default():
        tf.import_graph_def(graph_def, name="")
    return graph

# Nạp model Inception-v3 đã retrain
GRAPH_PATH = "/home/pi/our_data/retrained_graph.pb"
LABELS_PATH = "/home/pi/our_data/retrained_labels.txt"
labels = [line.rstrip() for line in open(LABELS_PATH)]
detection_graph = load_graph(GRAPH_PATH)

input_operation = detection_graph.get_operation_by_name("DecodeJpeg/contents")
output_operation = detection_graph.get_operation_by_name("final_result")

print("[INFO] He thong phan loai san pham CNN da san sang...")

try:
    # Khởi động băng chuyền
    GPIO.output(PIN_MOTOR_IN1, GPIO.HIGH)
    GPIO.output(PIN_MOTOR_IN2, GPIO.LOW)
    
    with tf.Session(graph=detection_graph) as sess:
        while True:
            # Kiểm tra trạng thái cảm biến hồng ngoại (Mức 0 = Có vật)
            if GPIO.input(PIN_IR_SENSOR) == GPIO.LOW:
                # 1. Dừng băng tải tạm thời để chụp ảnh ổn định
                GPIO.output(PIN_MOTOR_IN1, GPIO.LOW)
                
                # 2. Chụp khung hình từ Pi Camera
                image_path = "/home/pi/scratch/capture.jpg"
                os.system("raspistill -w 320 -h 240 -t 100 -o " + image_path)
                
                # 3. Đọc dữ liệu ảnh và suy luận qua mô hình CNN
                with open(image_path, 'rb') as f:
                    image_data = f.read()
                
                predictions = sess.run(output_operation.outputs[0], 
                                      {input_operation.outputs[0]: image_data})
                top_k = predictions[0].argsort()[-len(predictions[0]):][::-1]
                
                top_label = labels[top_k[0]]
                confidence = predictions[0][top_k[0]]
                print("[RESULT] Phat hien: %s - Do tin cay: %.2f%%" % (top_label, confidence * 100))
                
                # 4. Kích hoạt cơ cấu gạt phân loại
                if top_label == "hop_to":
                    print("[ACTION] Kich hoat Servo gat Hop To...")
                    set_servo_angle(90)  # Gạt góc 90 độ
                    time.sleep(0.5)
                    set_servo_angle(0)   # Trở về vị trí ban đầu
                
                # Tiếp tục cho băng tải vận hành
                GPIO.output(PIN_MOTOR_IN1, GPIO.HIGH)
                time.sleep(0.5)
            time.sleep(0.05)

except KeyboardInterrupt:
    print("[STOP] Dung he thong.")
    pwm_servo.stop()
    pwm_motor.stop()
    GPIO.cleanup()

Thử nghiệm và đánh giá chất lượng mô hình

Tập dữ liệu kiểm nghiệm độc lập (Test Set) gồm 150 bức ảnh (50 ảnh Hộp to, 50 ảnh Hộp nhỏ, 50 ảnh Empty) hoàn toàn không nằm trong tập huấn luyện được đưa vào kiểm định:

Nhãn phân loại Số mẫu huấn luyện Số mẫu kiểm tra Dự đoán đúng (TP) Dự đoán sai (FP) Độ chính xác (Precision)
Hộp to 200 50 48 2 96.0%
Hộp nhỏ 200 50 47 3 94.0%
Empty (Trống) 100 50 49 1 98.0%
Tổng cộng / TB 500 150 144 6 96.0%

Ma trận nhầm lẫn (Confusion Matrix)

                 Dự đoán: Hộp To   Dự đoán: Hộp Nhỏ   Dự đoán: Empty
Thực tế: Hộp To        48                 2                 0
Thực tế: Hộp Nhỏ        2                47                 1
Thực tế: Empty          0                 1                49

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

  1. Hiệu năng nhận diện vượt chỉ tiêu: Mô hình đạt độ chính xác trung bình toàn hệ thống 96.0% trên tập kiểm tra thực tế (vượt mục tiêu ban đầu đề ra là > 90%).
  2. Tối ưu hóa thời gian đáp ứng: Thời gian từ lúc cảm biến hồng ngoại phát hiện vật thể, kích hoạt Camera Pi chụp ảnh, trích xuất đặc trưng qua TensorFlow và đưa tín hiệu kích hoạt Servo MG996 đạt trung bình 420ms, đảm bảo sản phẩm được gạt chính xác vào thùng chứa mà không bị trượt khỏi vị trí.
  3. Độ ổn định cơ điện: Hệ thống phần cứng hoạt động liên tục trong 2 giờ thử nghiệm với hơn 300 chu kỳ phân loại sản phẩm mà không gặp sự cố sụt áp hay treo bo mạch điều khiển.

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

  • Tối ưu hóa học sâu cho hệ thống nhúng biên (Edge AI Deployment): Đề tài chứng minh tính khả thi của việc triển khai các mạng neural tích chập hiện đại (Inception-v3) trên nền tảng phần cứng siêu tiết kiệm chi phí như Raspberry Pi 3 mà không cần máy chủ phụ trợ.
  • Ứng dụng kỹ thuật Bottleneck Caching: Giảm thiểu thời gian huấn luyện mô hình phân loại tùy biến từ nhiều ngày (nếu huấn luyện mạng CNN từ đầu trên GPU) xuống chỉ còn 12 phút trên máy tính thông thường trước khi chuyển giao đồ thị nhị phân .pb xuống thiết bị nhúng.
  • Loại bỏ sự phụ thuộc vào điều kiện ánh sáng khắt khe: Khác với các thuật toán tách biên màu sắc hoặc khớp mẫu (Template Matching) truyền thống vốn dễ vỡ trận khi cường độ sáng thay đổi, các bộ lọc tích chập học được các đặc trưng không gian (Spatial Hierarchies) sâu, giúp phân biệt kích thước hình học chính xác ngay cả khi bóng đổ hoặc ánh sáng môi trường dao động tới $\pm 25%$.
  • Kiến trúc module hóa linh hoạt: Phần cứng và phần mềm được thiết kế tách lớp. Khi nhà máy bổ sung mẫu sản phẩm mới (ví dụ: chai nước, linh kiện điện tử), người vận hành chỉ cần bổ sung thư mục ảnh mẫu mới và chạy lại kịch bản retrain mà không cần can thiệp vào cơ cấu cơ khí hay thiết kế lại mạch điện.

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

Kịch bản ứng dụng trong sản xuất thực tế

                       DÂY CHUYỀN SẢN XUẤT THỰC TẾ
                                    |
            +-----------------------+-----------------------+
            |                                               |
            v                                               v
[Ngành Đóng Gói Thực Phẩm]                     [Logistics & Chuyển Phát Nhanh]
- Phân loại trái cây, nông sản                 - Phân loại bưu kiện theo kích cỡ
- Phát hiện bao bì lỗi thể tích                - Điều hướng gói hàng tự động
  1. Ngành nông sản và thực phẩm: Phân loại tự động kích thước các loại củ quả (cam, táo, thanh long) hoặc phân loại hộp bánh kẹo thành phẩm đóng gói sai quy cách.
  2. Logistics và bưu chính: Phân luồng bưu kiện nhỏ tại các hub chuyển phát nhanh dựa trên hình dạng hình học và kích thước thực tế.
  3. Sản xuất linh kiện điện tử: Phân loại các khối module, hộp linh kiện bán dẫn theo mẫu mã bao bì trước khi đưa vào kho lưu trữ tự động.

Phân tích hiệu quả kinh tế và thời gian hoàn vốn (ROI)

  • Chi phí chế tạo nguyên mẫu:
    • Máy tính nhúng Raspberry Pi 3 Model B + Nguồn 5V/2.5A: 950.000 VNĐ
    • Module Raspberry Pi Camera V1 5MP: 250.000 VNĐ
    • Module công suất L298N + Động cơ DC giảm tốc + Khung băng tải: 600.000 VNĐ
    • Động cơ Servo MG996 kim loại + Cảm biến hồng ngoại LM393: 200.000 VNĐ
    • Vật tư cơ khí, mica, ốc vít, nguồn phụ: 300.000 VNĐ
    • Tổng chi phí phần cứng: 2.300.000 VNĐ (chưa tới $100 USD).
  • Hiệu quả đầu tư: So với việc trang bị các bộ camera công nghiệp chuyên dụng (Smart Camera của Cognex, Keyence có giá từ $2.000 - $5.000 USD), giải pháp nhúng mã nguồn mở giúp doanh nghiệp vừa và nhỏ (SMEs) tiết kiệm hơn 90% chi phí đầu tư ban đầu, đạt điểm hòa vốn chỉ sau 1 - 2 tháng vận hành thay thế nhân công thủ công.

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

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

  • Tốc độ khung hình (Frame Rate): Do chạy suy luận hoàn toàn bằng CPU ARM Cortex-A53 của Raspberry Pi 3B (không có chip tăng tốc đồ họa NPU chuyên dụng), tốc độ suy luận bị giới hạn ở mức 2 khung hình/giây. Điều này yêu cầu băng tải phải duy trì tốc độ di chuyển vừa phải ($v \le 0.15\text{ m/s}$) hoặc phải dừng ngắn để chụp ảnh.
  • Độ phân giải tập dữ liệu: Dữ liệu huấn luyện đang xử lý ở mức chuẩn $320 \times 240$ pixels để tối ưu hóa bộ nhớ RAM 1GB của kit nhúng.
  • Phân loại theo góc nhìn cố định: Camera được đặt thẳng đứng từ trên xuống, hệ thống chỉ nhận diện tốt các đặc trưng kích thước nhìn từ mặt trên (Top-down View).

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

  • Nâng cấp kiến trúc mạng nhẹ (Lightweight Deep Learning): Chuyển đổi mô hình sang MobileNetV3 hoặc YOLOv8-Nano kết hợp định dạng nén lượng tử hóa TensorFlow Lite (TFLite INT8) để tăng tốc độ suy luận lên trên 15 FPS.
  • Tích hợp phần cứng gia tốc AI (Edge TPU / NPU): Bổ sung thanh tăng tốc Google Coral USB Accelerator hoặc nâng cấp lên board mạch Raspberry Pi 5 / Jetson Nano để xử lý phân loại thời gian thực ở độ phân giải 4K mà không cần dừng băng chuyền.
  • Tích hợp IoT Công nghiệp (IIoT): Kết nối giao thức MQTT truyền dữ liệu thống kê sản lượng theo thời gian thực lên Dashboard máy chủ đám mây, tích hợp chuẩn giao tiếp công nghiệp RS485 / Modbus để kết nối trực tiếp với các bộ điều khiển lập trình PLC trong nhà máy.

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

  • Sinh viên ngành Kỹ thuật Máy tính, Điện tử & Tự động hóa: Cung cấp tài liệu tham khảo hoàn chỉnh từ thiết kế mạch công suất, lập trình giao tiếp GPIO, xử lý xung PWM đến việc cấu hình và nhúng thư viện TensorFlow trên hệ điều hành Linux.
  • Kỹ sư lập trình nhúng & Computer Vision: Mẫu kiến trúc thực tế minh chứng cách áp dụng Transfer Learning và trích xuất Bottleneck để giải quyết bài toán thị giác máy tính thực tế với chi phí tính toán tối thiểu.
  • Doanh nghiệp sản xuất vừa và nhỏ (SMEs): Cung cấp bản thiết kế hệ thống tự động hóa chi phí cực thấp, dễ dàng bảo trì và có khả năng tự động thích nghi nhanh với các thay đổi quy cách sản phẩm.
  • Các nhóm nghiên cứu ứng dụng AI: Cơ sở dữ liệu và phương pháp kiểm chứng thực nghiệm về độ suy giảm hiệu năng khi đưa mô hình học sâu từ môi trường máy chủ xuống môi trường biên tài nguyên hạn chế.

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

1. Yêu cầu kỹ thuật phần cứng và phần mềm tối thiểu để triển khai hệ thống là gì?

Hệ thống yêu cầu bo mạch tối thiểu từ Raspberry Pi 3 Model B (RAM 1GB), thẻ nhớ MicroSD tối thiểu 16GB Class 10 (tốc độ đọc/ghi $\ge 80\text{MB/s}$), Camera Pi CSI 5MP và nguồn cấp $5\text{V}/2.5\text{A}$ chuẩn cho bo mạch trung tâm. Về phần mềm, hệ thống chạy trên nền tảng Raspbian OS (Linux Kernel 4.x), Python 2.7/3.4 và gói phân phối TensorFlow 1.0 dành cho kiến trúc ARMv7l.

2. Giới hạn mở rộng phân loại (Scalability) của mô hình là bao nhiêu và cách khắc phục khi cần phân loại nhiều sản phẩm hơn?

Về mặt lý thuyết, tầng Softmax cuối cùng có thể mở rộng lên hàng chục hoặc hàng trăm nhãn sản phẩm khác nhau. Tuy nhiên, khi số lượng nhãn tăng lên và các sản phẩm có hình thái tương đồng cao, cần chụp bổ sung tối thiểu 150 - 200 ảnh cho mỗi nhãn mới ở nhiều điều kiện sáng khác nhau. Nếu số lượng nhãn vượt quá 20 lớp, nên chuyển đổi mô hình sang kiến trúc MobileNetV2 kết hợp bộ nhớ đệm RAM tối thiểu 2GB để đảm bảo không bị tràn bộ nhớ nhúng (Out of Memory).

3. Hệ thống có thể tích hợp với các dây chuyền PLC và SCADA hiện hữu như thế nào?

Raspberry Pi có thể đóng vai trò như một cảm biến thị giác thông minh (Vision Sensor). Tín hiệu đầu ra từ chân GPIO (hoặc thông qua mạch cách ly quang Optocoupler) có thể đưa trực tiếp vào ngõ vào Digital Input 24V của PLC (Siemens S7-1200, Mitsubishi FX5U). Ngoài ra, hệ thống hoàn toàn có thể truyền thông dữ liệu nhãn sản phẩm và độ tin cậy thông qua giao thức truyền thông công nghiệp Modbus TCP/IP qua cổng mạng RJ45 tích hợp sẵn trên Pi.

4. Quy trình bảo trì và cập nhật mô hình AI khi có sản phẩm mới diễn ra ra sao?

Quy trình cập nhật gồm 3 bước nhanh:

  1. Tạo thư mục mới mang tên nhãn sản phẩm trong thư mục image/ và lưu trữ khoảng 150 - 200 bức ảnh chụp mẫu mới.
  2. Chạy kịch bản retrain.py trên máy tính cá nhân để tạo lại tệp retrained_graph.pb và retrained_labels.txt (thời gian chạy mất khoảng 10 - 15 phút).
  3. Sao chép 2 tệp nhị phân mới ghi đè vào thư mục /home/pi/our_data/ trên Raspberry Pi qua giao thức SFTP hoặc USB mà không cần biên dịch lại toàn bộ hệ điều hành.

5. Bảng phân tích chi phí đầu tư và thời gian thu hồi vốn (ROI) cụ thể?

Với chi phí hoàn thiện một trạm phân loại dưới 2.500.000 VNĐ và công suất tiêu thụ điện cực thấp (~ 7W cho toàn bộ hệ thống), chi phí vận hành hàng tháng chỉ khoảng 50.000 VNĐ tiền điện. So với một nhân công phân loại thủ công với mức lương 7.000.000 VNĐ/tháng, doanh nghiệp có thể hoàn vốn đầu tư chỉ sau 10 đến 15 ngày làm việc của thiết bị.

Kết luận

Đề tài "Ứng dụng công nghệ CNN vào việc phân loại sản phẩm trên băng chuyền" đã giải quyết thành công bài toán tự động hóa nhận diện và phân loại sản phẩm dựa trên thị giác máy tính hiện đại. Bằng việc kết hợp sáng tạo giữa mô hình mạng neural tích chập Inception-v3, kỹ thuật học chuyển tiếp Transfer Learning và nền tảng máy tính nhúng Raspberry Pi 3 Model B, hệ thống đạt độ chính xác phân loại ấn tượng 96.0%, thời gian phản hồi cơ cấu chấp hành đạt 420ms với mức chi phí chế tạo dưới 2.500.000 VNĐ.

Thành công của đề tài không chỉ khẳng định tính khả thi của việc ứng dụng Trí tuệ nhân tạo biên (Edge AI) trong môi trường công nghiệp thực tế mà còn mở ra hướng tiếp cận chi phí thấp, hiệu quả cao cho các doanh nghiệp đang trong quá trình chuyển đổi số dây chuyền sản xuất. Các kỹ sư và nhà phát triển có thể kế thừa kiến trúc này, mở rộng thêm các mô hình mạng nén như MobileNet hay TFLite để xây dựng các giải pháp tự động hóa thông minh hơn trong tương lai.