实战项目三：机器学习推理——TensorFlow Lite集成、模型加载、推理接口封装、性能基准测试

说实话，这个项目是我在课程里最期待的一个。为什么？因为现在做Android开发，不会点机器学习推理，总觉得少了点什么。我去年帮一个智能门锁厂商做离线人脸识别，就是在嵌入式设备上跑TFLite模型。那会儿踩的坑，今天全给你们抖出来。

咱们这个项目，说白了就是三件事：把TFLite塞进NDK、把模型跑起来、把性能测明白。别被“机器学习”四个字吓到，咱们不搞算法训练，只搞推理集成。你想想看，模型是数据科学家训练好的，咱们的任务就是让它能在Android设备上高效运行。

1. TFLite的NDK集成方式

集成TFLite到NDK，有两种主流方式。我个人的习惯是直接用官方提供的预编译库，省心。但如果你对模型有特殊优化需求，比如要用GPU委托或者XNNPACK，那就得自己编译了。

先看最简单的集成方式——在CMakeLists.txt里直接引用：

# 方式一：使用预编译的TFLite C API库
add_library(tensorflowlite STATIC IMPORTED)
set_target_properties(tensorflowlite PROPERTIES
    IMPORTED_LOCATION ${CMAKE_SOURCE_DIR}/libs/${ANDROID_ABI}/libtensorflowlite_c.so
)

# 方式二：如果下载了完整源码，可以用FetchContent
include(FetchContent)
FetchContent_Declare(
    tensorflow
    GIT_REPOSITORY https://github.com/tensorflow/tensorflow.git
    GIT_TAG v2.12.0
    GIT_SHALLOW TRUE
)
# 注意：完整编译TFLite非常耗时，我建议只在CI环境里做

这里有个坑——ABI匹配。我曾经在项目里把arm64-v8a的库塞到了armeabi-v7a的设备上，结果一加载就崩。嗯，这种低级错误犯一次就够了。

2. 模型加载与内存管理

模型加载，核心就两个步骤：读取模型文件到内存，然后创建解释器。但这里的内存管理，很多人会翻车。

看代码：

// 模型加载——我习惯用mmap，省一次内存拷贝
int load_model(const char* model_path, TfLiteModel** model) {
    // 读取文件到buffer
    FILE* f = fopen(model_path, "rb");
    fseek(f, 0, SEEK_END);
    long model_size = ftell(f);
    rewind(f);
    
    char* model_buffer = (char*)malloc(model_size);
    fread(model_buffer, 1, model_size, f);
    fclose(f);
    
    // 创建TFLite模型
    *model = TfLiteModelCreate(model_buffer, model_size);
    
    // 注意：TfLiteModelCreate内部会拷贝数据
    // 所以这里可以安全释放model_buffer
    free(model_buffer);
    
    return 0;
}

// 创建解释器
TfLiteInterpreterOptions* options = TfLiteInterpreterOptionsCreate();
TfLiteInterpreterOptionsSetNumThreads(options, 4);  // 4线程推理

TfLiteInterpreter* interpreter = 
    TfLiteInterpreterCreate(*model, options);

你可能会问：为什么要先读到buffer再传给API？直接传文件路径不行吗？不行。TFLite的C API设计就是基于buffer的，它需要你把整个模型文件加载到内存。我刚开始也纳闷，后来想想——这样方便从assets目录或者网络流加载，灵活性更高。

3. 推理接口的封装设计

封装推理接口，我建议遵循一个原则：对外暴露简单，对内保留灵活。说白了，上层调用者只需要“输入数据→拿到结果”，至于底层是用CPU还是GPU、用几个线程，别让他们操心。

这是我常用的封装结构：

// 推理引擎类——面向对象的封装
class InferenceEngine {
public:
    // 初始化：加载模型、创建解释器
    bool init(const char* model_path, int threads = 4);
    
    // 推理：输入float数组，输出float数组
    bool infer(const float* input, float* output, int input_size);
    
    // 获取输入输出张量信息
    int get_input_size();
    int get_output_size();
    
    // 资源释放
    void release();
    
private:
    TfLiteModel* model_;
    TfLiteInterpreter* interpreter_;
    TfLiteInterpreterOptions* options_;
    
    // 内部辅助方法
    bool set_input_tensor(const float* data, int size);
    bool get_output_tensor(float* data, int size);
};

实现的时候，有个细节要注意——张量维度的检查。我曾经在项目里没做输入尺寸校验，结果模型训练时是224x224的输入，我传了个512x512的图进去，推理结果完全不对，还没报错。这种静默错误最坑人。

bool InferenceEngine::infer(const float* input, float* output, int input_size) {
    // 获取输入张量
    TfLiteTensor* input_tensor = TfLiteInterpreterGetInputTensor(interpreter_, 0);
    
    // 检查输入尺寸——这一步不能省
    int expected_size = 1;
    for (int i = 0; i < input_tensor->dims->size; i++) {
        expected_size *= input_tensor->dims->data[i];
    }
    
    if (input_size != expected_size) {
        __android_log_print(ANDROID_LOG_ERROR, "TFLite", 
            "输入尺寸不匹配: 期望 %d, 实际 %d", expected_size, input_size);
        return false;
    }
    
    // 拷贝输入数据
    memcpy(input_tensor->data.f, input, input_size * sizeof(float));
    
    // 执行推理
    TfLiteInterpreterInvoke(interpreter_);
    
    // 获取输出
    const TfLiteTensor* output_tensor = TfLiteInterpreterGetOutputTensor(interpreter_, 0);
    memcpy(output, output_tensor->data.f, output_size_ * sizeof(float));
    
    return true;
}

4. 性能基准测试方法

性能测试，不能只测一次就下结论。我一般会跑100次预热+1000次正式测试，取P50、P90、P99三个分位值。为什么？因为Android设备有温控降频，第一次跑和第十次跑的结果可能差3倍。

这是我的测试框架：

// 性能基准测试
void benchmark(InferenceEngine* engine, int iterations = 1000) {
    // 准备随机输入数据
    int input_size = engine->get_input_size();
    float* input = (float*)malloc(input_size * sizeof(float));
    float* output = (float*)malloc(engine->get_output_size() * sizeof(float));
    
    // 随机初始化
    for (int i = 0; i < input_size; i++) {
        input[i] = (float)rand() / RAND_MAX;
    }
    
    // 预热——让设备进入稳定状态
    for (int i = 0; i < 100; i++) {
        engine->infer(input, output, input_size);
    }
    
    // 正式测试——记录每次耗时
    std::vector<long> latencies;
    for (int i = 0; i < iterations; i++) {
        auto start = std::chrono::high_resolution_clock::now();
        engine->infer(input, output, input_size);
        auto end = std::chrono::high_resolution_clock::now();
        
        long us = std::chrono::duration_cast<std::chrono::microseconds>(end - start).count();
        latencies.push_back(us);
    }
    
    // 排序并计算分位值
    std::sort(latencies.begin(), latencies.end());
    long p50 = latencies[iterations * 50 / 100];
    long p90 = latencies[iterations * 90 / 100];
    long p99 = latencies[iterations * 99 / 100];
    
    __android_log_print(ANDROID_LOG_INFO, "Benchmark",
        "P50: %ld us, P90: %ld us, P99: %ld us", p50, p90, p99);
    
    free(input);
    free(output);
}

5. 不同推理配置的对比

为了让你有个直观感受，我拿一个MobileNetV2模型在骁龙865设备上做了测试。结果如下：

看到没？GPU委托虽然平均快，但P99抖动很大。我分析过原因——GPU驱动在后台有任务切换，偶尔会卡一下。所以如果你做实时性要求高的应用（比如相机滤镜），我建议用CPU多线程，虽然慢点但稳。

6. 知识体系总览

下面这张图，把整个项目的核心逻辑串起来了。你可以把它当作一个检查清单——每完成一个模块，就打个勾。

这张图里，我特意把“性能基准测试”放在最下面，因为它是对前面所有工作的验证。你想想看，集成做得再好，模型加载再快，如果推理性能不达标，一切都是白搭。

好了，这个项目的内容就这些。从集成方式到模型加载，从接口封装到性能测试，每一步我都把实际项目中踩过的坑告诉你了。记住一句话：机器学习推理在NDK层面，本质上就是高效的数据搬运和计算调度。别被“AI”两个字唬住，动手做一遍，你就发现其实没那么神秘。