ESP32 小模型部署实验：合成数据、PTQ与目标自检

# ---- main/idf_component.yml ----
dependencies:
  idf: "==5.5.5"
  espressif/esp-dl: "==3.3.8"
  espressif/dl_fft: "==0.8.0"

// ---- main/pixels.h ----
/* SPDX-License-Identifier: MIT */
#pragma once
#include <stdint.h>
/* Fixed exported input exponent -7: real=pixel/255, q=round_half_up(real*128).
 * Inputs are nonnegative. Saturate128 to127, never wrap into a negative int8. */
static inline int8_t v05_quantize_pixel(uint8_t pixel) {
    unsigned q=((unsigned)pixel*128U+127U)/255U;
    return(int8_t)(q>127U?127U:q);
}

# ---- main/CMakeLists.txt ----
include(${CMAKE_CURRENT_LIST_DIR}/inputs.cmake)
foreach(item shape-s3.espdl heldout-pixels.bin heldout-labels.bin)
    file(SHA256 "${CMAKE_CURRENT_LIST_DIR}/${item}" actual_sha)
    if(NOT actual_sha STREQUAL "${V05_SHA_${item}}")
        message(FATAL_ERROR "V05 input identity mismatch: ${item}")
    endif()
endforeach()
idf_component_register(SRCS "main.cpp" INCLUDE_DIRS "." REQUIRES esp-dl esp_timer heap esp_psram
    EMBED_FILES "shape-s3.espdl" "heldout-pixels.bin" "heldout-labels.bin")
target_compile_definitions(${COMPONENT_LIB} PRIVATE V05_MODEL_SHA256="${V05_SHA_shape-s3.espdl}")

// ---- main/main.cpp ----
/* SPDX-License-Identifier: MIT */
#include <cstdio>
#include <cinttypes>
#include <cstring>
#include "dl_model_base.hpp"
#include "esp_heap_caps.h"
#include "esp_timer.h"
#include "esp_system.h"
#include "esp_psram.h"
#include "pixels.h"
extern const uint8_t model_start[] asm("_binary_shape_s3_espdl_start");
extern const uint8_t pixels_start[] asm("_binary_heldout_pixels_bin_start");
extern const uint8_t pixels_end[] asm("_binary_heldout_pixels_bin_end");
extern const uint8_t labels_start[] asm("_binary_heldout_labels_bin_start");
extern const uint8_t labels_end[] asm("_binary_heldout_labels_bin_end");
static void memory(const char *phase) {
    printf("MEM,%s,internal_free=%u,internal_largest=%u\n",phase,
        (unsigned)heap_caps_get_free_size(MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT),
        (unsigned)heap_caps_get_largest_free_block(MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT));
    printf("PSRAM,%s,free=%u,largest=%u\n",phase,
        (unsigned)heap_caps_get_free_size(MALLOC_CAP_SPIRAM|MALLOC_CAP_8BIT),
        (unsigned)heap_caps_get_largest_free_block(MALLOC_CAP_SPIRAM|MALLOC_CAP_8BIT));
}
extern "C" void app_main(void) {
    printf("V05,SYNTHETIC_HELDOUT_ONLY,idf=%s\nMODEL_SHA256,%s\n",esp_get_idf_version(),V05_MODEL_SHA256);
    if((size_t)(pixels_end-pixels_start)!=128U*256U||(size_t)(labels_end-labels_start)!=128U){printf("STOP,case_lengths\n");return;}
    if(!esp_psram_is_initialized()||esp_psram_get_size()!=8U*1024U*1024U){printf("STOP,requires_8MiB_PSRAM\n");return;}
    memory("before_model");const int64_t load_start=esp_timer_get_time();
    auto *model=new dl::Model((const char*)model_start,fbs::MODEL_LOCATION_IN_FLASH_RODATA);
    printf("LOAD,us=%" PRId64 "\n",esp_timer_get_time()-load_start);memory("loaded");
    /* Runs the standard exporter-stored reference, not a probability threshold. */
    const esp_err_t test=model->test();printf("EXPORT_REFERENCE_TEST,%s\n",esp_err_to_name(test));
    if(test!=ESP_OK){delete model;printf("STOP,reference_mismatch\n");return;}
    auto *input=model->get_input();auto *output=model->get_output();
    if(!input||!output||input->dtype!=dl::DATA_TYPE_INT8||output->dtype!=dl::DATA_TYPE_INT8||
       input->shape!=std::vector<int>({1,16,16,1})||(input->exponent.is_per_channel()||input->exponent.get()!=-7)||output->exponent.is_per_channel()||output->get_size()!=2){
        delete model;printf("STOP,export_contract\n");return;
    }
    unsigned confusion[2][2]={{0,0},{0,0}};
    for(unsigned n=0;n<128;n++) {
        if(labels_start[n]>1){printf("STOP,label_range\n");delete model;return;}
        auto *destination=(int8_t*)input->data;
        for(unsigned i=0;i<256;i++)destination[i]=v05_quantize_pixel(pixels_start[n*256+i]);
        const int64_t began=esp_timer_get_time();model->run();const int64_t elapsed=esp_timer_get_time()-began;
        const auto *logits=(const int8_t*)output->data;const unsigned prediction=logits[1]>logits[0]?1:0;
        confusion[labels_start[n]][prediction]++;
        printf("CASE,test-%04u,truth=%u,pred=%u,raw0=%d,raw1=%d,exponent=%d,us=%" PRId64 "\n",n,(unsigned)labels_start[n],prediction,(int)logits[0],(int)logits[1],output->exponent.get(),elapsed);
    }
    printf("SYNTHETIC_CONFUSION,circle=%u/%u,square=%u/%u\n",confusion[0][0],confusion[0][1],confusion[1][0],confusion[1][1]);
    memory("after_128");delete model;memory("released");
    printf("END,no_camera_no_GPIO_no_real_object_accuracy\n");
}