ESP-DL 第一份推理：先跑官方小模型，再理解输入输出

// ---- main/main.cpp ----
/* SPDX-License-Identifier: MIT */
#include <cmath>
#include <cinttypes>
#include <cstdio>
#include "dl_image_jpeg.hpp"
#include "imagenet_cls.hpp"
#include "esp_heap_caps.h"
#include "esp_psram.h"
#include "esp_timer.h"
#include "esp_system.h"

extern const uint8_t image_start[] asm("_binary_cat_jpg_start");
extern const uint8_t image_end[] asm("_binary_cat_jpg_end");
static void memory(const char *phase) {
    printf("MEM,%s,internal_free=%u,internal_largest=%u,psram_free=%u,psram_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),
        (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("V03,software_fixed_image_only,idf=%s\nIMAGE_SHA256,%s\nMODEL_SHA256,%s\n",
           esp_get_idf_version(),V03_IMAGE_SHA256,V03_MODEL_SHA256);
    memory("before_decode");
    if(!esp_psram_is_initialized()||esp_psram_get_size()!=8U*1024*1024) {
        printf("STOP,8MiB_OPI_PSRAM_required; no inference attempted\n");return;
    }
    const int64_t began=esp_timer_get_time();
    dl::image::jpeg_img_t jpeg={.data=(void*)image_start,.data_len=(size_t)(image_end-image_start)};
    auto image=dl::image::sw_decode_jpeg(jpeg,dl::image::DL_IMAGE_PIX_TYPE_RGB888);
    if(!image.data||image.width!=300||image.height!=300) {
        printf("STOP,decode_or_fixed_image_dimensions\n");heap_caps_free(image.data);return;
    }
    printf("DECODE,image_rgb888=%ux%u,us=%" PRId64 "\n",(unsigned)image.width,(unsigned)image.height,esp_timer_get_time()-began);
    memory("decoded");
    const int64_t load_begin=esp_timer_get_time();
    /* Explicit type; false loads now so construction is excluded from each run. */
    auto *classifier=new ImageNetCls(ImageNetCls::MOBILENETV2_S8_V1,false);
    printf("MODEL_LOAD,us=%" PRId64 "\n",esp_timer_get_time()-load_begin);
    memory("loaded");
    for(unsigned run=0;run<3;run++) {
        const int64_t start=esp_timer_get_time();
        const auto &results=classifier->run(image);
        const int64_t elapsed=esp_timer_get_time()-start;
        printf("RUN,%u,pipeline_us=%" PRId64 ",topk=%u\n",run,elapsed,(unsigned)results.size());
        bool valid=results.size()==5;float previous=2.0f;
        for(size_t i=0;i<results.size();i++) {
            const auto &result=results[i];
            valid=valid&&std::isfinite(result.score)&&result.score>=0&&result.score<=1&&result.score<=previous;
            previous=result.score;
            printf("TOP,%u,%u,label=%s,softmax_score=%.9f\n",run,(unsigned)i+1,result.cat_name,result.score);
        }
        if(!valid){printf("STOP,invalid_top5_contract\n");break;}
        memory("after_run");
    }
    delete classifier;heap_caps_free(image.data);memory("released");
    printf("END,no_camera_no_RF; score_is_not_accuracy_or_calibrated_probability\n");
}

// ---- main/CMakeLists.txt ----
idf_component_register(SRCS "main.cpp" INCLUDE_DIRS "."
    REQUIRES imagenet_cls esp_timer heap esp_psram
    EMBED_FILES "cat.jpg")
file(SHA256 "${CMAKE_CURRENT_LIST_DIR}/cat.jpg" fixed_jpeg_sha)
if(NOT fixed_jpeg_sha STREQUAL "71a56b94233940cfc942457f3413ed248b847db4110eced52768852d87320508")
    message(FATAL_ERROR "V03 fixed upstream cat.jpg hash mismatch; retain input and inspect source")
endif()
idf_component_get_property(imagenet_dir espressif__imagenet_cls COMPONENT_DIR)
set(model "${imagenet_dir}/models/s3/imagenet_cls_mobilenetv2_s8_v1.espdl")
file(SHA256 "${model}" fixed_model_sha)
if(NOT fixed_model_sha STREQUAL "59124aace8bd5cd9e502b938b7d90c9f0949949ee0087b3841911f6a785180db")
    message(FATAL_ERROR "V03 fixed upstream S3 model hash mismatch; do not relabel another model")
endif()
target_compile_definitions(${COMPONENT_LIB} PRIVATE
    V03_IMAGE_SHA256="${fixed_jpeg_sha}" V03_MODEL_SHA256="${fixed_model_sha}")

# ---- tools/check_inputs.py ----
#!/usr/bin/env python3
# SPDX-License-Identifier: MIT
"""Check the exact two trusted inputs. Pillow decode is a host check, not ESP inference."""
import argparse,hashlib,json,pathlib
IMAGE_SHA='71a56b94233940cfc942457f3413ed248b847db4110eced52768852d87320508'
MODEL_SHA='59124aace8bd5cd9e502b938b7d90c9f0949949ee0087b3841911f6a785180db'
def exact(path,size,digest):
    data=pathlib.Path(path).read_bytes()
    if len(data)!=size or hashlib.sha256(data).hexdigest()!=digest:raise ValueError('fixed input size/SHA mismatch: '+str(path))
    return data
def check(image,model=None):
    data=exact(image,35952,IMAGE_SHA)
    from PIL import Image,__version__
    with Image.open(image)as im:
        im.load()
        if im.format!='JPEG'or im.size!=(300,300):raise ValueError('fixed JPEG format/dimensions')
        rgb=im.convert('RGB');rgb_sha=hashlib.sha256(rgb.tobytes()).hexdigest()
    result=dict(imageSHA256=IMAGE_SHA,jpegBytes=len(data),dimensions=[300,300],hostRGB888Bytes=270000,hostRGB888SHA256=rgb_sha,pillow=__version__,scope='Host Pillow decoding and file identity only; does not execute ESP-DL, equal ESP JPEG pixels, measure latency, classify or prove board PSRAM.')
    if model is not None:
        data=exact(model,3611648,MODEL_SHA)
        if data[:4]!=b'EDL2':raise ValueError('expected fixed EDL2 package header')
        result.update(modelSHA256=MODEL_SHA,modelBytes=len(data),modelHeader='EDL2')
    return result
def main():
    root=pathlib.Path(__file__).resolve().parents[1]
    p=argparse.ArgumentParser();p.add_argument('--image',type=pathlib.Path,default=root/'main/cat.jpg');p.add_argument('--model',type=pathlib.Path);a=p.parse_args()
    try:result=check(a.image,a.model)
    except(OSError,ValueError)as error:p.error(str(error))
    print(json.dumps(result,indent=2))
if __name__=='__main__':main()