Ch25: MNN 实战——转换、推理、量化一条龙

// mnn_classify.cpp
#include <stdio.h>
#include <vector>
#include <algorithm>
#include <MNN/Interpreter.hpp>
#include <MNN/MNNDefine.h>
#include <MNN/Tensor.hpp>
#include <MNN/ImageProcess.hpp>

int main(int argc, char** argv) {
    if (argc != 3) {
        printf("Usage: %s <model.mnn> <image>\n", argv[0]);
        return -1;
    }

    // ========== 1. 创建 Interpreter ==========
    // Interpreter 负责模型的加载和管理
    std::shared_ptr<MNN::Interpreter> interpreter(
        MNN::Interpreter::createFromFile(argv[1])
    );
    if (!interpreter) {
        printf("Failed to create interpreter\n");
        return -1;
    }

    // ========== 2. 配置 Session ==========
    MNN::ScheduleConfig config;
    config.numThread = 4;                    // CPU 线程数
    config.type = MNN_FORWARD_CPU;           // 后端类型

    // 后端特定配置
    MNN::BackendConfig backendConfig;
    backendConfig.precision = MNN::BackendConfig::Precision_Normal;
    // Precision_Low    = fp16（更快但精度低）
    // Precision_Normal = fp32（默认）
    // Precision_High   = fp32 + 额外精度保证
    config.backendConfig = &backendConfig;

    // ========== 3. 创建 Session ==========
    // Session 是推理的执行环境
    MNN::Session* session = interpreter->createSession(config);
    if (!session) {
        printf("Failed to create session\n");
        return -1;
    }

    // ========== 4. 获取输入 Tensor ==========
    // nullptr 表示获取第一个（默认的）输入
    MNN::Tensor* inputTensor = interpreter->getSessionInput(session, nullptr);

    // 打印输入信息
    auto shape = inputTensor->shape();
    printf("Input shape: ");
    for (int s : shape) printf("%d ", s);
    printf("\n");

    // ========== 5. 准备输入数据 ==========
    // 方法 A：使用 ImageProcess（推荐用于图片输入）
    int inputHeight = shape[2];   // NCHW 格式
    int inputWidth = shape[3];

    // 加载图片（这里用伪代码，实际需要用 stb_image 等库）
    // unsigned char* imageData = load_image(argv[2], &imgWidth, &imgHeight);

    // 配置图像预处理
    MNN::CV::ImageProcess::Config imgConfig;
    imgConfig.filterType = MNN::CV::BILINEAR;    // 缩放插值方式
    imgConfig.sourceFormat = MNN::CV::RGBA;      // 输入图片格式
    imgConfig.destFormat = MNN::CV::BGR;         // 模型需要的格式

    // 设置 mean 和 norm（和训练时一致）
    const float mean[3] = {103.94f, 116.78f, 123.68f};
    const float norm[3] = {0.017f, 0.017f, 0.017f};
    ::memcpy(imgConfig.mean, mean, sizeof(mean));
    ::memcpy(imgConfig.normal, norm, sizeof(norm));

    std::shared_ptr<MNN::CV::ImageProcess> pretreat(
        MNN::CV::ImageProcess::create(imgConfig)
    );

    // 设置缩放矩阵
    MNN::CV::Matrix matrix;
    matrix.postScale(
        (float)inputWidth / imgWidth,
        (float)inputHeight / imgHeight
    );
    pretreat->setMatrix(matrix);

    // 方法 B：直接填充浮点数据（适合非图片输入或已预处理的数据）
    auto inputHost = new MNN::Tensor(inputTensor, MNN::Tensor::CAFFE);
    // CAFFE 表示 NCHW 布局，TENSORFLOW 表示 NHWC 布局

    float* inputData = inputHost->host<float>();
    // 手动填充数据...
    // for (int i = 0; i < inputHost->elementSize(); i++) {
    //     inputData[i] = preprocessed_value;
    // }

    // 把数据从 Host Tensor 拷贝到 Session 的 Input Tensor
    inputTensor->copyFromHostTensor(inputHost);

    // ========== 6. 执行推理 ==========
    interpreter->runSession(session);

    // ========== 7. 获取输出 ==========
    MNN::Tensor* outputTensor = interpreter->getSessionOutput(session, nullptr);

    // 创建 Host Tensor 来接收输出
    auto outputHost = new MNN::Tensor(outputTensor, MNN::Tensor::CAFFE);
    outputTensor->copyToHostTensor(outputHost);

    // ========== 8. 解析结果 ==========
    float* outputData = outputHost->host<float>();
    int outputSize = outputHost->elementSize();

    // 找 Top-5
    std::vector<std::pair<float, int>> scores;
    for (int i = 0; i < outputSize; i++) {
        scores.push_back({outputData[i], i});
    }
    std::sort(scores.begin(), scores.end(),
              [](const auto& a, const auto& b) { return a.first > b.first; });

    printf("Top-5 results:\n");
    for (int i = 0; i < 5 && i < outputSize; i++) {
        printf("  class %d: %.4f\n", scores[i].second, scores[i].first);
    }

    // ========== 9. 清理 ==========
    delete inputHost;
    delete outputHost;
    // Session 由 Interpreter 管理，不需要手动 delete
    // Interpreter 由 shared_ptr 管理，自动释放

    return 0;
}

// 错误做法：直接读 Device Tensor
MNN::Tensor* output = interpreter->getSessionOutput(session, nullptr);
float* data = output->host<float>();  // 危险！可能读到错误数据

// 正确做法：创建 Host Tensor，拷贝后再读
MNN::Tensor* output = interpreter->getSessionOutput(session, nullptr);
auto hostOutput = new MNN::Tensor(output, MNN::Tensor::CAFFE);
output->copyToHostTensor(hostOutput);
float* data = hostOutput->host<float>();  // 安全

auto interpreter = MNN::Interpreter::createFromFile("model.mnn");
auto session = interpreter->createSession(config);
auto input = interpreter->getSessionInput(session, nullptr);
// 填充输入...
interpreter->runSession(session);
auto output = interpreter->getSessionOutput(session, nullptr);

#include <MNN/expr/Module.hpp>
#include <MNN/expr/Executor.hpp>
#include <MNN/expr/ExprCreator.hpp>

using namespace MNN::Express;

// 创建 Module
std::shared_ptr<Module> module(Module::load(
    {"input0"},      // 输入名列表
    {"output0"},     // 输出名列表
    "model.mnn"
));

// 创建输入
auto input = _Input({1, 3, 224, 224}, NCHW, halide_type_of<float>());
auto inputPtr = input->writeMap<float>();
// 填充数据到 inputPtr...
input->unMap();

// 前向推理
auto outputs = module->onForward({input});
auto outputPtr = outputs[0]->readMap<float>();
// 读取结果...

// 简略示例——实际使用较少
auto pipeline = interpreter->createPipeline(session, config);
pipeline->encode(inputs);
pipeline->submit();
pipeline->wait();
pipeline->decode(outputs);

// bench_mnn.cpp
#include <stdio.h>
#include <chrono>
#include <MNN/Interpreter.hpp>

int main(int argc, char** argv) {
    auto interpreter = MNN::Interpreter::createFromFile(argv[1]);

    MNN::ScheduleConfig config;
    config.numThread = 4;
    config.type = MNN_FORWARD_CPU;

    auto session = interpreter->createSession(config);
    auto input = interpreter->getSessionInput(session, nullptr);

    // 创建随机输入
    auto hostInput = new MNN::Tensor(input, MNN::Tensor::CAFFE);
    auto data = hostInput->host<float>();
    for (int i = 0; i < hostInput->elementSize(); i++) {
        data[i] = 0.5f;
    }
    input->copyFromHostTensor(hostInput);

    // 预热
    for (int i = 0; i < 3; i++) {
        interpreter->runSession(session);
    }

    // 正式测试
    int loops = 20;
    double total = 0;
    for (int i = 0; i < loops; i++) {
        auto start = std::chrono::high_resolution_clock::now();
        interpreter->runSession(session);
        auto end = std::chrono::high_resolution_clock::now();
        double ms = std::chrono::duration<double, std::milli>(end - start).count();
        total += ms;
        printf("Run %d: %.2f ms\n", i + 1, ms);
    }
    printf("Average: %.2f ms\n", total / loops);

    delete hostInput;
    delete interpreter;
    return 0;
}

// 正确：用 Device Tensor 的 shape 创建 Host Tensor
auto hostTensor = new MNN::Tensor(deviceTensor, MNN::Tensor::CAFFE);

// 错误：手动指定了不匹配的 shape
auto hostTensor = new MNN::Tensor({1, 3, 224, 224}, ...);  // shape 可能不对