YOLOX Nano를 사용하는 ESP32 HMI에서 실시간 인원 계수

 

많은 보안 감시 및 스마트 출입 통제 시나리오에서, 특히 낮은 지연 시간과 개인 정보 보호가 중요한 경우, 로컬 장치에서 직접 실시간 인원 계수를 수행해야 하는 수요가 증가하고 있습니다. 기존의 클라우드 기반 솔루션은 이러한 요구를 충족하지 못하는 경우가 많습니다.

 

이 글에서는 강력한 ESP32-S3 칩과 고품질 터치스크린(예: Elecrow CrowPanel 시리즈)이 탑재된 ESP32 HMI 모듈 과 OV2640 카메라를 결합하여 강력한 엣지 AI 솔루션을 구축하는 방법을 소개합니다.

 

경량 객체 감지 모델인 YOLOX Nano를 활용하여 모델 준비 및 양자화부터 최종 배포 및 실행까지 아두이노 환경에서의 전체 과정을 자세히 설명합니다. 이 글의 목표는 개발자들이 "로컬 추론, 실시간 표시, 저지연 응답"이라는 엣지 AI 기술을 쉽게 습득하여, 풍부한 기능을 갖춘 ESP32 HMI 장치에 강력한 시각적 인식 기능을 부여하여 진정한 실시간 인원 계수를 구현할 수 있도록 하는 것입니다.

 

실시간 인원 계수에 YOLOX Nano + ESP32 HMI를 선택해야 하는 이유는 무엇일까요?

 

리소스가 제한된 마이크로컨트롤러에 엣지 AI 모델을 배포할 때 모델과 플랫폼 선택은 성공에 매우 중요합니다. YOLOX Nano와 최신 ESP32 HMI(특히 ESP32-S3 기반 버전)의 조합은 실시간 인원 계수 구현에 상당한 이점을 제공합니다.

 

1. 경량화되고 효율적인 엣지 AI 솔루션:

 

• YOLOX Nano 모델 자체는 파라미터 수가 적어 ESP32 HMI 와 같은 장치에 임베디드 배포하기에 매우 적합합니다 .
• INT8 모델 양자화 후 크기가 1MB 미만으로 크게 줄어들어 ESP32 HMI의 저장 용량에 완벽하게 들어맞습니다.
• ESP32-S3 칩에 내장된 벡터 명령어 가속 기능은 YOLOX Nano의 로컬 추론 속도를 초당 4~6프레임까지 향상시킬 수 있습니다. 이는 실시간 인원 계수와 같은 객체 감지 애플리케이션의 기본 속도 요구 사항을 충분히 충족하므로 효율적인 엣지 AI 애플리케이션 구축에 이상적인 선택입니다.

 

2. 목표에 집중하고, 정확도를 제어하세요:

 

• 사전 학습된 YOLOX Nano 모델은 이미 "사람" 클래스를 인식할 수 있으므로 기본적인 인원 계수 작업에 직접 사용할 수 있습니다.
• YOLOX Nano는 정밀 조정을 통해 사람을 식별하는 특정 객체 감지 작업에 특화될 수 있으며, ESP32 HMI에서 정확도와 로컬 추론 속도를 더욱 최적화하여 실시간 인원 계수의 신뢰성을 향상시킬 수 있습니다.

 

3. 잘 구축된 생태계, 손쉽게 시작 가능:

 

• Espressif는 ESP32-S3와 같은 칩용 ESP-DL 라이브러리와 ESP-PPQ 모델 양자화 툴체인을 제공하여 ONNX와 같은 형식에서 YOLOX Nano와 같은 엣지 AI 모델을 배포하는 프로세스를 간소화합니다.
• 풍부한 문서, 커뮤니티 지원, 그리고 Arduino IDE 및 LVGL과 같은 라이브러리와의 뛰어난 통합 덕분에 IPS 스크린과 터치스크린을 탑재한 ESP32 HMI 장치에서 실시간 인원 계수와 같은 엣지 AI 애플리케이션을 개발하는 것이 훨씬 쉬워졌습니다.

 

모델 준비 및 ONNX 내보내기(PC 측)

 

ESP32 HMI용 YOLOX Nano 모델을 준비하는 첫 번째 단계는 PC에서 수행됩니다. 이는 엣지 AI 워크플로우에서 매우 중요한 부분입니다.

 

1. 환경 설정:

 

(앞서 언급한 대로 torch, torchvision, onnx, YOLOX와 같은 필수 라이브러리가 설치되어 있는지 확인하십시오.)

 

pip install torch torchvision onnx
git clone https://github.com/Megvii-BaseDetection/YOLOX.git
cd YOLOX
pip install -r requirements.txt
pip install -e .

 

 

이는 YOLOX Nano 모델을 내보내고 후속 모델 양자화를 위한 기반을 형성하여 ESP32-S3에서 최종적으로 실행할 수 있도록 준비합니다.

 

2. 모델 구성(선택 사항):

 

(앞서 언급했듯이) 실시간 인원 계수 애플리케이션에 더 높은 정확도가 필요한 경우 YOLOX Nano를 미세 조정하여 '사람' 클래스를 더욱 정확하게 감지하도록 할 수 있습니다.

 

3. ONNX 모델 내보내기:

 

(앞서 제공된 명령어를 사용하되, 경로와 매개변수가 올바른지 확인하십시오.)

 

python tools/export_onnx.py \
  --output-name yolox_nano_person.onnx \
  -n yolox-nano \
  -f exps/default/yolox_nano.py \
  --export_batch_size 1 \
  --decode_in_inference \
  # -c path/to/your/checkpoint.pth # If using custom weights

 

 

YOLOX Nano 모델을 ONNX 형식으로 내보내는 것은 플랫폼 간 배포 및 모델 양자화를 위한 표준 단계이며, ESP32 HMI에서 효율적인 로컬 추론을 위한 준비 단계입니다.

 

모델 양자화 및 변환(PC 측)

 

ESP32 HMI에서 부동 소수점 ONNX 모델을 직접 실행하는 것은 비효율적이고 리소스 소모가 심합니다. 모델 양자화는 로컬 추론 속도를 향상시키고 메모리 사용량을 줄이는 핵심적인 엣지 AI 최적화 기술이며, 이는 ESP32-S3 칩에 YOLOX Nano를 배포하는 데 필수적입니다.

 

1. 양자화 도구를 설치하세요:

 

(이전과 같이 espressif-esp-ppq를 설치하세요.)

 

pip install espressif-esp-ppq torch_ppq

 

 

2. 양자화 및 변환을 수행합니다.

 

(표시된 대로 ppq 명령어를 사용하고, 보정 데이터를 제공하며 입력 형태를 지정하십시오.)

 

ppq quantize \
  --platform esp-dl \
  --input_model ./yolox_nano_person.onnx \
  --input_shape "[1, 3, 224, 224]" \
  --calib_data ./calib_images/ \
  --quant_format espdl \
  --output_dir ./esp_model_output/ \
  --equalization

 

 

이 단계에서는 보정 데이터를 사용하여 YOLOX Nano에서 INT8 모델 양자화를 수행하고 .espdlESP32 HMI의 ESP-DL 라이브러리에 적합한 파일을 생성합니다. 모델 양자화는 실시간 인원 계수를 위한 로컬 추론 성능을 크게 향상시키며, 성공적인 엣지 AI 구축의 핵심 요소입니다.

 

장치 배포 및 실시간 추론(아두이노 환경)

 

이제 양자화된 YOLOX Nano 모델을 ESP32 HMI 모듈에 배포하고, 아두이노 코드를 사용하여 실시간 인원 계수 기능을 구현하고 결과를 HMI 디스플레이에 표시합니다.

 

1. 프로젝트 파일 구조 (예시):

 

PlatformIO 또는 유사한 도구를 사용하여 프로젝트를 구성하고, 설명된 대로 .espdl 파일을 data/ 디렉터리에 배치하십시오.

 

YourProject/
├── platformio.ini
├── data/
│   └── model.espdl     # Quantized YOLOX Nano model for ESP32-S3
├── include/
├── lib/
├── src/
│   ├── main.cpp        # Main logic: person counting & HMI display
│   ├── camera_utils.cpp/h
│   ├── model_utils.cpp/h
│   └── ui_utils.cpp/h  # UI logic (potentially using LVGL)
└── CMakeLists.txt      # If using ESP-IDF directly

 

 

.espdl 모델 파일이 ESP32 HMI의 파일 시스템(예: SPIFFS)에 업로드되었는지 확인하십시오. 그래야 Arduino 코드가 이를 로드하여 엣지 AI 추론을 수행할 수 있습니다.

 

2. 아두이노 핵심 코드 로직 (`main.cpp` 예시):

 

#include 
#include "esp_camera.h"
#include "esp_dl_model.h"      // ESP-DL for YOLOX Nano loading & inference on ESP32-S3
#include "dl_lib_matrix3d.h"
#include "FS.h"
#include "SPIFFS.h"            // Or LittleFS.h
// #include "lvgl.h"           // Include LVGL if using it for the ESP32 HMI display

// --- Config for YOLOX Nano on ESP32 HMI (ESP32-S3 based) ---
#define MODEL_INPUT_WIDTH  224 // Must match quantization input_shape
#define MODEL_INPUT_HEIGHT 224
#define MODEL_PATH "/model.espdl" // Path to quantized YOLOX Nano on filesystem
#define PERSON_CLASS_ID 0      // COCO class ID for person
#define CONFIDENCE_THRESHOLD 0.5f // Threshold for valid object detection

// Global model handle for YOLOX Nano
esp_dl_model_handle_t model_handle = {0};

// Function prototypes
void setupCamera();
void setupFileSystem();
void loadModel();
bool image_preprocess(camera_fb_t *fb, dl_matrix3du_t *out_tensor); // CRITICAL
void updateDisplayOnHMI(int count); // For updating the HMI Display

void setup() {
  Serial.begin(115200);
  Serial.println("ESP32 HMI Real-time Person Counting with YOLOX Nano (Edge AI Demo)");

  setupFileSystem(); // Initialize File System (SPIFFS/LittleFS)
  setupCamera();     // Initialize Camera connected to the ESP32 HMI
  loadModel();       // Load the quantized YOLOX Nano model for local inference

  // Initialize the HMI Display, Touch Screen, and LVGL (if used)
  // setupLVGL_On_ESP32_HMI();
  Serial.println("Setup complete. Starting loop for Real-time Person Counting...");
}

void loop() {
  camera_fb_t *fb = esp_camera_fb_get(); // Get frame from camera
  if (!fb) {
    Serial.println("Camera capture failed");
    delay(1000);
    return;
  }

  int personCount = 0; // Initialize count for this frame

  if (model_handle) { // Check if YOLOX Nano model is loaded
    dl_matrix3du_t *input_tensor = dl_matrix3du_alloc(1, MODEL_INPUT_WIDTH, MODEL_INPUT_HEIGHT, 3);
    if(!input_tensor){
        Serial.println("Failed to allocate input tensor");
        esp_camera_fb_return(fb);
        return;
    }

    // !!! CRITICAL: Implement image_preprocess function for ESP32 HMI !!!
    // Convert camera frame (fb->buf, potentially YUV/JPEG) to RGB format
    // Resize to MODEL_INPUT_WIDTH x MODEL_INPUT_HEIGHT for YOLOX Nano.
    // This preprocessing step is vital for accurate Edge AI results.
    bool success = image_preprocess(fb, input_tensor);

    if (success) {
      // --- Perform YOLOX Nano Local Inference for Object Detection ---
      // Leverage ESP32-S3's Vector Instructions for acceleration
      struct timeval start_time, end_time;
      gettimeofday(&start_time, NULL);

      esp_dl_model_run(model_handle, (dl_matrix3d_t *)input_tensor); // Run inference

      gettimeofday(&end_time, NULL);
      long elapsed_ms = (end_time.tv_sec - start_time.tv_sec) * 1000 + (end_time.tv_usec - start_time.tv_usec) / 1000;
      // Serial.printf("Inference Time: %ld ms\n", elapsed_ms); // Optional: print inference time

      // --- Process YOLOX Nano Results for Real-time Person Counting ---
      // NOTE: You need to implement the logic to parse the output tensor from YOLOX Nano.
      // This involves getting bounding boxes, scores, and class IDs.
      // The exact method depends on how ESP-DL exposes results for your model configuration.
      // Apply Non-Maximum Suppression (NMS) if it wasn't part of the exported model.
      // Pseudo-code below assumes you have a function `parse_yolox_output`
      // std::vector detections = parse_yolox_output(model_handle);
      // for (const auto& det : detections) {
      //    if (det.class_id == PERSON_CLASS_ID && det.score > CONFIDENCE_THRESHOLD) {
      //        personCount++; // Increment count for each detected person
      //    }
      //}
      // Replace pseudo-code with actual result parsing!

      Serial.printf("Detected Persons: %d\n", personCount); // Print count to Serial

      // Update the display on the ESP32 HMI's Touch Screen / IPS Screen
      updateDisplayOnHMI(personCount); // Function to draw count on the HMI Display (e.g., using LVGL)

    } else {
        Serial.println("Image preprocessing failed.");
    }
    dl_matrix3du_free(input_tensor); // Free the input tensor memory
  } else {
      // Serial.println("Model not loaded, skipping inference."); // Debug message
  }

  esp_camera_fb_return(fb); // Return camera frame buffer IMPORTANT!

  // Adjust delay to balance performance and responsiveness for Real-time Person Counting
  delay(100); // Controls processing loop frequency on the ESP32 HMI (adjust as needed)
}

void loadModel() {
  // Load the quantized YOLOX Nano model prepared for Edge AI on ESP32-S3
  if (!SPIFFS.begin(true)) {
      Serial.println("SPIFFS Mount Failed");
      return;
  }
  if (SPIFFS.exists(MODEL_PATH)) {
      model_handle = esp_dl_model_load(MODEL_PATH);
      if (!model_handle) {
          Serial.printf("Failed to load YOLOX Nano model from %s for ESP32 HMI\n", MODEL_PATH);
      } else {
          Serial.println("YOLOX Nano model loaded successfully for Edge AI inference.");
      }
  } else {
      Serial.printf("Model file not found at %s\n", MODEL_PATH);
  }
}

// --- Placeholder Function Definitions ---
void setupCamera() {
    // Implement camera initialization logic for your ESP32 HMI hardware
    Serial.println("Camera Initialized (Placeholder).");
}

void setupFileSystem() {
    if (!SPIFFS.begin(true)) {
        Serial.println("An Error has occurred while mounting SPIFFS");
        return;
    }
    Serial.println("SPIFFS Mounted successfully.");
}

void updateDisplayOnHMI(int count) {
    // Implement your display update logic here using LVGL or another library
    // Example: lv_label_set_text_fmt(ui_person_count_label, "Persons: %d", count);
    // Serial.printf("Updating HMI Display with count: %d (Placeholder)\n", count); // Debug print
}

// !!! CRITICAL IMPLEMENTATION NEEDED !!!
bool image_preprocess(camera_fb_t *fb, dl_matrix3du_t *out_tensor) {
    // 1. Convert frame buffer (fb->buf, format fb->format) to RGB.
    // 2. Resize the RGB image to MODEL_INPUT_WIDTH x MODEL_INPUT_HEIGHT.
    // 3. Normalize pixel values if required by the YOLOX Nano model.
    // 4. Fill the data into out_tensor->item pointer (check HWC or CHW order).
    // Use libraries like esp_camera utility functions or esp_image_lib if available.
    Serial.println("image_preprocess() needs implementation!");
    return false; // Return true on success
}

 

 

이 아두이노 코드는 ESP32 HMI에 최적화된 YOLOX Nano 모델을 로드하고, ESP32-S3의 효율적인 로컬 추론 기능을 활용하여 실시간 인원 계수를 위한 핵심 로직을 구현하는 방법을 보여줍니다. 객체 감지 결과(인원 수)는 LVGL과 같은 라이브러리를 사용하여 ESP32 HMI의 IPS 화면/터치스크린에 시각화할 수 있습니다.

 

성능 최적화 팁 (ESP32 HMI 기반 YOLOX Nano 사용 시)

 

• 해상도 절충: 입력 해상도를 조정하는 것은 실시간 인원 계수 속도와 객체 감지 정확도 사이의 균형을 맞추는 데 핵심입니다. ESP32 HMI에서 최적의 지점을 찾아보세요.
• 전처리 최적화: 이미지 변환은 로컬 추론 파이프라인에서 종종 병목 현상을 일으키는 부분입니다. ESP32-S3에 맞게 이 부분을 최적화하는 것이 매우 중요합니다.
• 안정적인 처리 주기: ESP32 HMI 시스템의 안정성과 터치스크린의 반응성을 보장하기 위해 프레임 속도를 적절하게 제어합니다.
• 벡터 명령어 활용: ESP32-S3를 사용하고 개발 환경이 벡터 명령어를 활성화하도록 올바르게 구성되었는지 확인하십시오. 이를 통해 엣지 AI 시나리오에서 YOLOX Nano의 성능을 극대화할 수 있습니다.
• 모델 선택: 매우 까다로운 실시간 인원 계수 작업의 경우, ESP32 HMI에서 더욱 가벼운 객체 감지 모델을 사용하는 것을 고려해 보세요.

 

이 튜토리얼에서는 효율적인 YOLOX Nano 객체 감지 모델을 활용하여 강력한 ESP32 HMI 플랫폼(특히 ESP32-S3 칩이 탑재된 모델에 적합)에서 완전한 로컬 추론 기반 실시간 인원 계수 기능을 구현하는 방법을 자세히 설명했습니다. ONNX 모델 준비부터 핵심 기술인 모델 양자화, 아두이노 환경에서의 최종 엣지 AI 배포 및 HMI 디스플레이에 결과 표시까지 전체 워크플로를 다뤘습니다.

 

ESP32 HMI와 YOLOX Nano를 기반으로 하는 이 엣지 AI 솔루션은 ESP32-S3의 벡터 명령어 가속 기능을 활용합니다. 이를 통해 응답 속도를 향상시키고 데이터 개인정보를 보호할 뿐만 아니라, 임베디드 장치에 전례 없는 지능형 비전 기능을 제공합니다. 이 솔루션을 시작점으로 삼아 실시간 인원 계수 기능을 더욱 복잡한 스마트 방문객 시스템이나 보안 애플리케이션으로 확장하여 ESP32 HMI 의 엣지 AI 단말기로서의 잠재력을 최대한 활용할 수 있습니다. 지금 바로 ESP32 HMI의 IPS 화면에 YOLOX Nano를 연결하고 엣지 AI의 무한한 가능성을 경험해 보세요!

 

기사 원문 링크를 보시려면 여기를 클릭하세요.