ESP32-CAM边缘AI货币识别：TensorFlow Lite Micro嵌入式部署实战

1. 项目缘起：当ESP32-CAM遇上货币识别

最近在捣鼓一个挺有意思的玩意儿：用ESP32-CAM这块小小的开发板，结合边缘AI技术，来实现一个离线、低成本的货币识别系统。你可能觉得，现在手机App扫一扫就能查汇率，这玩意儿有啥用？但实际场景里，还真有不少地方需要这种“离线、嵌入式”的识别能力。

比如，一些自动售货机、自助兑换机，或者是一些特定场所的财务盘点设备，它们需要快速、准确地识别不同面额的纸币或硬币，但又不可能、也不方便时刻保持联网。再比如，一些面向视障人士的辅助设备，如果能集成一个本地化的货币识别模块，就能在不依赖网络、不泄露隐私的情况下，帮助他们独立完成日常支付。这就是边缘AI的魅力所在——把智能计算从云端“拉”到设备端，让设备自己就能“看懂”世界。

ESP32-CAM是个绝佳的选择。它集成了ESP32这颗强大的Wi-Fi/蓝牙双模芯片，以及一颗OV2640摄像头模组，体积小巧、功耗低，最关键的是价格极其亲民。而“Currency Recognition with Edge AI”这个标题，就点明了项目的核心： 在资源受限的嵌入式设备上，部署一个轻量级的神经网络模型，让它能实时“看见”并“理解”眼前的货币 。这不仅仅是跑通一个Demo，更是对嵌入式AI应用落地的一次深度探索，涉及到模型选择、裁剪、量化、部署、优化等一系列实战环节。

2. 核心挑战与方案选型：为何是TensorFlow Lite Micro？

要实现这个目标，我们面临几个核心挑战：

1. 算力与内存限制 ：ESP32-CAM的主频通常为240MHz，SRAM大约520KB，这远低于我们熟悉的PC或手机。
2. 模型尺寸限制 ：程序需要和模型一起存储在有限的Flash中（通常4MB或16MB）。
3. 实时性要求 ：从采集图像到输出识别结果，需要在几百毫秒内完成，才能有较好的交互体验。
4. 离线运行 ：所有计算必须在设备端完成，不能依赖网络API。

面对这些挑战， TensorFlow Lite for Microcontrollers (TF Lite Micro) 几乎是当前的最优解。它是一个专为微控制器和嵌入式设备设计的推理框架，核心优势在于：

• 极致的轻量级 ：运行时库本身非常小，核心引擎可以压缩到仅几十KB。
• 算子支持优化 ：针对ARM Cortex-M系列处理器（ESP32的内核基于Xtensa，但TF Lite Micro有较好的移植支持）进行了算子优化。
• 模型量化支持 ：支持将训练好的浮点模型转换为8位整数（INT8）格式，在几乎不损失精度的情况下，将模型大小减少至1/4，并大幅提升推理速度。
• 跨平台部署 ：模型格式统一，可以在PC端训练、转换，然后部署到嵌入式设备上。

为什么不选其他框架？比如PyTorch Mobile更适合移动端（Android/iOS），其微控制器版本生态相对TF Lite Micro仍不成熟。至于一些更轻量的推理引擎（如NNoM、TinyML），虽然更小，但社区支持、工具链完整度和模型兼容性上，TF Lite Micro目前仍是主流和更稳妥的选择。

因此，我们的技术栈就明确了： 在PC端使用TensorFlow/Keras训练一个货币分类模型，然后使用TF Lite Converter将其转换为TF Lite格式并进行量化，最后集成到ESP32-CAM的Arduino工程中，通过TF Lite Micro解释器进行推理。

3. 从零构建货币数据集与模型训练

模型要识别的准，首先得“吃”得好。数据是AI的基石。对于货币识别，理想的数据集应该包含：

• 多角度 ：同一张货币，从不同角度、不同距离拍摄的照片。
• 多光照 ：在明亮、昏暗、背光、侧光等不同光照条件下的照片。
• 多状态 ：崭新、陈旧、轻微褶皱、部分遮挡的货币照片。
• 背景复杂 ：货币放在桌子、钱包、手掌等不同背景上。

3.1 数据采集与预处理实战

由于公开的、包含多国货币且符合我们需求的数据集很少，自制数据集往往是必经之路。这里分享我的采集经验：

1. 采集工具 ：直接使用ESP32-CAM本身进行采集是最佳选择。编写一个简单的Arduino程序，将摄像头拍摄的图片通过Wi-Fi传输到电脑端保存。这样可以确保训练数据的成像特性（如镜头畸变、颜色偏差、分辨率）与最终应用场景完全一致，这是提升模型最终精度的关键技巧。
2. 采集脚本示例 （Arduino端思路）：

   // 伪代码思路：连接Wi-Fi后，启动一个Web服务器
   // 当访问特定URL（如 /capture）时，拍摄一张照片并返回
   #include <WiFi.h>
   #include <WebServer.h>
   #include "esp_camera.h"
   
   WebServer server(80);
   
   void handleCapture() {
     camera_fb_t *fb = esp_camera_fb_get();
     if (!fb) {
       server.send(500, "text/plain", "Camera capture failed");
       return;
     }
     server.send(200, "image/jpeg", (const char *)fb->buf, fb->len);
     esp_camera_fb_return(fb);
   }
   
   void setup() {
     // 初始化摄像头和Wi-Fi
     // ...
     server.on("/capture", handleCapture);
     server.begin();
   }
   

   在电脑端，你可以用Python脚本循环访问ESP32-CAM的IP地址，比如 http://192.168.1.100/capture ，来批量保存图片。
3. 数据标注 ：每张图片需要对应一个标签（如“USD_1”、“EUR_10”、“CNY_100”）。建议使用文件夹结构进行管理，每个类别的图片放入一个以标签名命名的文件夹。可以使用 ImageDataGenerator 来自动读取这种结构。
4. 预处理流程 ：
   • 统一尺寸 ：将图片缩放到模型输入尺寸，如96x96或160x160。更大的尺寸意味着更多的计算量，需要权衡。
   • 数据增强 ：在训练时实时进行，以扩充数据集多样性。包括随机旋转（小角度）、水平翻转、亮度/对比度微调、添加微小噪声等。 特别注意 ：货币识别中，垂直翻转通常不适用，因为纸币倒置可能代表不同含义（虽然很少见），且硬币正反面图案不同。
   • 归一化 ：将像素值从[0, 255]缩放到[0, 1]或[-1, 1]，有助于模型稳定训练。

3.2 轻量级模型选择与训练

在嵌入式设备上，我们无法使用ResNet、EfficientNet这类大型模型。我们的选择集中在MobileNet、MobileNetV2/V3的极简版本，或者自定义的微小CNN（Convolutional Neural Network）上。

• MobileNetV2 (Alpha=0.35, input=96x96) ：这是一个非常平衡的选择。通过深度可分离卷积（Depthwise Separable Convolution）大幅减少参数量和计算量。Alpha=0.35是宽度乘子，进一步压缩了通道数。96x96的输入在精度和速度间取得了良好平衡。这个模型经过ImageNet预训练，通过迁移学习能更快地在我们的货币数据集上收敛。
• 自定义微型CNN ：如果识别类别很少（比如只区分3-5种货币），一个4-6层的浅层CNN可能就足够了，模型尺寸可以做到更小（<50KB）。但需要自己设计结构，且特征提取能力较弱。

这里以MobileNetV2为例，展示训练核心代码框架：

import tensorflow as tf
from tensorflow.keras import layers, models
from tensorflow.keras.applications import MobileNetV2
from tensorflow.keras.preprocessing.image import ImageDataGenerator

# 参数
IMG_SIZE = (96, 96)
BATCH_SIZE = 32
NUM_CLASSES = 10  # 假设识别10种货币
DATA_DIR = 'path/to/your/currency_dataset'

# 数据生成器（包含增强）
train_datagen = ImageDataGenerator(
    rescale=1./255,
    rotation_range=15,
    width_shift_range=0.1,
    height_shift_range=0.1,
    brightness_range=[0.9, 1.1],
    horizontal_flip=True,  # 谨慎使用，见上文说明
    validation_split=0.2
)

train_generator = train_datagen.flow_from_directory(
    DATA_DIR,
    target_size=IMG_SIZE,
    batch_size=BATCH_SIZE,
    class_mode='categorical',
    subset='training'
)

val_generator = train_datagen.flow_from_directory(
    DATA_DIR,
    target_size=IMG_SIZE,
    batch_size=BATCH_SIZE,
    class_mode='categorical',
    subset='validation'
)

# 构建模型：使用预训练的MobileNetV2，去掉顶层，自定义分类头
base_model = MobileNetV2(input_shape=(96, 96, 3),
                         include_top=False,
                         weights='imagenet',
                         alpha=0.35)  # 宽度乘子，越小模型越轻量

# 冻结基础模型，先只训练顶层
base_model.trainable = False

model = models.Sequential([
    base_model,
    layers.GlobalAveragePooling2D(),
    layers.Dropout(0.2),  # 防止过拟合
    layers.Dense(NUM_CLASSES, activation='softmax')
])

model.compile(optimizer='adam',
              loss='categorical_crossentropy',
              metrics=['accuracy'])

# 第一阶段训练：只训练自定义的顶层
initial_epochs = 10
history = model.fit(train_generator,
                    validation_data=val_generator,
                    epochs=initial_epochs)

# 第二阶段：解冻部分基础模型，进行微调
base_model.trainable = True
# 通常解冻最后几十层，具体数量需要实验
fine_tune_at = 100
for layer in base_model.layers[:fine_tune_at]:
    layer.trainable = False

model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=1e-5),  # 使用更小的学习率
              loss='categorical_crossentropy',
              metrics=['accuracy'])

total_epochs = initial_epochs + 10
history_fine = model.fit(train_generator,
                         validation_data=val_generator,
                         initial_epoch=history.epoch[-1],
                         epochs=total_epochs)

注意： 在货币识别中，正反面是不同的类别。例如，“USD_1_obverse”和“USD_1_reverse”应该被视为两个独立的类别进行训练，除非你的应用场景能确保只看到一面。

4. 模型量化、转换与部署到ESP32-CAM

训练得到浮点模型（.h5）后，我们需要对它进行“瘦身”和“加速”，才能放进ESP32-CAM。

4.1 训练后整数量化（Post-Training Quantization）

这是最关键的一步。量化将模型权重和激活值从32位浮点数（float32）转换为8位整数（int8）。好处显而易见：模型大小减少约75%，推理速度提升2-3倍，并且许多嵌入式硬件（如ESP32的某些指令）对整数运算有更好的支持。

import tensorflow as tf

# 加载训练好的模型
model = tf.keras.models.load_model('your_trained_model.h5')

# 创建一个代表性数据集（用于校准量化过程）
# 通常从验证集中取100-200张图片即可
def representative_data_gen():
    for image_batch, _ in val_generator.take(100): # 假设val_generator是你的验证集生成器
        yield [image_batch]

# 转换器
converter = tf.lite.TFLiteConverter.from_keras_model(model)

# 启用默认优化（包括量化感知训练的一些图优化）
converter.optimizations = [tf.lite.Optimize.DEFAULT]
# 指定代表性数据集进行校准
converter.representative_dataset = representative_data_gen
# 确保输入输出也是int8（如果支持），否则保持float32输入
converter.target_spec.supported_ops = [tf.lite.OpsSet.TFLITE_BUILTINS_INT8]
# 设置输入输出类型（可选，如果希望输入输出也是int8）
converter.inference_input_type = tf.int8  # or tf.uint8
converter.inference_output_type = tf.int8 # or tf.uint8

# 转换模型
tflite_quant_model = converter.convert()

# 保存量化模型
with open('currency_model_quant.tflite', 'wb') as f:
    f.write(tflite_quant_model)

4.2 将模型集成到Arduino项目

TF Lite Micro模型在Arduino中是以C字节数组的形式存在的。我们需要使用一个工具将 .tflite 文件转换为 .cpp 文件。

1. 使用 xxd 命令（Linux/Mac）或在线工具 ：

   xxd -i currency_model_quant.tflite > currency_model_data.cpp
   

   这会生成一个包含 unsigned char 数组的C++文件。你需要打开这个文件，将数组名改为一个更友好的名字，比如 g_currency_model_data ，并添加数组长度的变量 g_currency_model_len 。

2. Arduino项目结构 ：

   ESP32_CAM_Currency_Recognition/
   ├── ESP32_CAM_Currency_Recognition.ino
   ├── model/
   │   └── currency_model_data.cpp  # 转换后的模型数组
   └── ...
   

3. 安装必要的Arduino库 ：

   • ESP32 Arduino Core ：提供对ESP32芯片的支持。
   • TensorFlowLite_ESP32 ：这是一个针对ESP32移植的TF Lite Micro库。你可以在Arduino库管理中搜索安装，或者从GitHub手动安装。
   • EloquentTinyML （可选）：一个优秀的Arduino TinyML封装库，提供了更友好的API，但底层仍是TF Lite Micro。

4.3 编写推理代码框架

以下是基于EloquentTinyML库的简化示例，它封装了细节，更易于上手：

#include <EloquentTinyML.h>
#include "model/currency_model_data.h" // 包含模型数组

// 定义模型输入输出尺寸
#define NUMBER_OF_INPUTS  (96 * 96 * 3) // 96x96 RGB
#define NUMBER_OF_OUTPUTS 10 // 10种货币类别
#define TENSOR_ARENA_SIZE 80 * 1024 // 张量竞技场大小，根据模型调整，建议>=70KB

// 实例化TinyML解释器
Eloquent::TinyML::TfLite<NUMBER_OF_INPUTS, NUMBER_OF_OUTPUTS, TENSOR_ARENA_SIZE> ml;

// 类别标签
const char* LABELS[] = {"USD_1", "USD_5", "EUR_10", "CNY_100", /* ... */};

void setup() {
    Serial.begin(115200);
    delay(1000);

    // 初始化模型
    if (!ml.begin(g_currency_model_data, g_currency_model_len)) {
        Serial.println("模型初始化失败！");
        while (true);
    }
    Serial.println("模型加载成功！");

    // 初始化摄像头
    if (!initCamera()) {
        Serial.println("摄像头初始化失败！");
        while (true);
    }
    Serial.println("摄像头就绪！");
}

void loop() {
    // 1. 捕获一帧图像
    camera_fb_t *fb = esp_camera_fb_get();
    if (!fb) {
        Serial.println("摄像头捕获失败");
        return;
    }

    // 2. 图像预处理
    // 将图像从摄像头缓冲区（例如JPEG或RGB565）转换为模型需要的格式（96x96 RGB uint8数组）
    uint8_t input_tensor[NUMBER_OF_INPUTS];
    preprocessImage(fb->buf, fb->width, fb->height, fb->format, input_tensor);

    // 3. 运行推理
    float predictions[NUMBER_OF_OUTPUTS];
    uint32_t start = micros();
    ml.predict(input_tensor, predictions);
    uint32_t inference_time = micros() - start;

    // 4. 解析结果
    int predicted_class = ml.probaToClass(predictions);
    float confidence = predictions[predicted_class];

    Serial.print("推理耗时: ");
    Serial.print(inference_time / 1000.0);
    Serial.println(" ms");
    Serial.print("识别结果: ");
    Serial.print(LABELS[predicted_class]);
    Serial.print(" (置信度: ");
    Serial.print(confidence * 100);
    Serial.println("%)");

    // 5. 释放帧缓冲区
    esp_camera_fb_return(fb);

    delay(2000); // 每2秒识别一次
}

// 图像预处理函数（需要根据你的摄像头格式实现）
void preprocessImage(const uint8_t* src, int src_width, int src_height, pixformat_t format, uint8_t* dst) {
    // 这是一个复杂但关键的函数！
    // 1. 如果fb是JPEG格式，需要先解码（可以使用TJpgDec库）。
    // 2. 将图像缩放到96x96。
    // 3. 可能需要进行颜色空间转换（如RGB565 to RGB888）。
    // 4. 将像素值从[0,255]调整到模型输入范围（例如，对于int8量化模型，可能需要减去128）。
    // 以下是一个高度简化的伪代码逻辑：
    // for (int y = 0; y < 96; y++) {
    //     for (int x = 0; x < 96; x++) {
    //         int src_x = map(x, 0, 95, 0, src_width-1);
    //         int src_y = map(y, 0, 95, 0, src_height-1);
    //         uint16_t pixel = getPixelFromRGB565(src, src_width, src_x, src_y); // 假设是RGB565
    //         uint8_t r = (pixel >> 11) & 0x1F;
    //         uint8_t g = (pixel >> 5) & 0x3F;
    //         uint8_t b = pixel & 0x1F;
    //         // 转换为8位并调整范围（如果模型输入是int8，且均值为0）
    //         dst[(y*96 + x)*3 + 0] = (uint8_t)((r * 255.0 / 31.0) - 128); // R
    //         dst[(y*96 + x)*3 + 1] = (uint8_t)((g * 255.0 / 63.0) - 128); // G
    //         dst[(y*96 + x)*3 + 2] = (uint8_t)((b * 255.0 / 31.0) - 128); // B
    //     }
    // }
}

关键提示： preprocessImage 函数是整个项目中最容易出错、也最影响精度的部分。 必须确保在PC端训练时的预处理流程（缩放、归一化）与设备端的预处理流程完全一致。 一个常见的错误是训练时用 (x / 255.0) 归一化到[0,1]，而设备端却忘了做。对于量化模型，更要注意输入数据类型的匹配（uint8还是int8）。

5. 性能优化与实战调试技巧

当代码跑起来后，你会发现离“好用”还有距离。以下是几个关键的优化和调试方向：

5.1 内存管理：张量竞技场（Tensor Arena）

TF Lite Micro需要一个连续的内存块（张量竞技场）来分配中间张量。 TENSOR_ARENA_SIZE 的大小至关重要：

• 太小 ：会导致 AllocateTensors() 失败，报错 kTfLiteError 。
• 太大 ：会浪费宝贵的SRAM。 如何确定合适的大小？一个笨但有效的方法是：先设置一个较大的值（如100KB），在初始化后打印出实际使用量。

// 在EloquentTinyML中，可以尝试调用其内部方法获取信息，或者直接修改库文件添加日志。
// 更通用的方法是，在TF Lite Micro的源码中，找到记录内存使用峰值的地方。

通常，一个用于96x96输入的MobileNetV2量化模型，需要70-90KB的竞技场。ESP32-CAM的520KB SRAM中，还需要为摄像头缓冲区、Wi-Fi栈等留出空间，所以模型和竞技场必须足够精简。

5.2 推理速度优化

1. 使用ESP32的硬件加速 ：ESP32具有双核处理器和硬件乘法器。确保在Arduino IDE的“工具”菜单中，将“CPU Frequency”设置为最高（如240MHz），并将“Optimization”设置为“-O2”或“-Os”（尺寸优化）。
2. 降低图像分辨率 ：如果96x96的推理速度仍不理想，可以尝试降低到64x64。但这会牺牲精度，需要重新训练模型。
3. 模型剪枝 ：在训练后，移除模型中权重接近零的连接，可以进一步压缩模型。可以使用TensorFlow Model Optimization Toolkit。
4. 定点化而非量化 ：对于极致的速度，可以探索使用TensorFlow Lite for Microcontrollers的定点算子（如果支持你的模型结构），但这需要更深入的工程工作。

5.3 提升识别精度

1. 数据，数据，还是数据 ：模型在真实场景中识别不准，首要怀疑对象就是训练数据不够代表性。补充在目标环境（光线、角度、背景）下采集的数据。
2. 预处理对齐 ：再次强调，确保设备端的预处理与训练时百分百一致。可以先将设备端预处理后的图像通过串口发送到PC，用Python脚本可视化，看是否与训练样本看起来一致。
3. 后处理 ：不要只取最高置信度的类别。可以设置一个置信度阈值（如0.7），低于阈值则判定为“未知”。还可以加入简单的时序滤波，比如连续3帧都识别为同一类别才输出结果，以平滑抖动。
4. 区域聚焦 ：如果货币在图像中的位置相对固定，可以先进行目标检测（如使用一个非常轻量级的检测模型或传统的图像处理技术找到货币区域），然后只对该区域进行裁剪和分类，可以减少背景干扰。

5.4 串口调试与可视化

将调试信息通过串口打印出来是必不可少的：

• 打印预处理前后图像的统计信息（均值、方差）。
• 打印每一帧的推理时间和置信度。
• 在识别错误时，将捕获的图像保存到SD卡（如果ESP32-CAM模块有SD卡槽），便于后续分析。

6. 从原型到产品：系统集成与扩展思考

当单个货币识别模块稳定工作后，我们可以考虑将其集成到一个更大的系统中。

6.1 系统集成示例

设想一个简单的自助收银台原型：

1. 触发 ：通过红外传感器或重量传感器检测到有货币放入。
2. 采集与识别 ：ESP32-CAM拍摄照片并进行本地识别，得到货币面额和币种。
3. 通信 ：通过ESP32的Wi-Fi，将识别结果（如 {“currency”: “CNY”, “value”: 10} ）以JSON格式发送给后台服务器（如运行在树莓派或云端的服务）。
4. 业务逻辑 ：后台服务器累加金额，更新账单，并控制显示屏反馈给用户。
5. 低功耗设计 ：在没有检测到物体时，ESP32-CAM可以进入深度睡眠模式，仅由传感器中断唤醒，极大节省能耗。

6.2 扩展方向

1. 多模态识别 ：除了图像，是否可以结合重量传感器（用于硬币）或红外/紫外光检测（用于防伪特征）来提升准确率和安全性？
2. 模型在线更新 ：能否设计一个机制，当发现新的假币或新版本货币时，可以通过OTA（Over-The-Air）方式安全地更新设备端的模型？
3. 更复杂的模型 ：如果需要同时识别货币的正反面、新旧程度甚至破损情况，可能需要更复杂的模型结构，如物体检测（YOLO Tiny）或分割模型，这对ESP32-CAM的算力将是巨大挑战，可能需要升级到ESP32-S3（带向量指令）或使用外置AI加速芯片。

6.3 避坑总结

回顾整个项目，以下几个坑是我亲身踩过，值得你特别注意的：

• 预处理不一致是精度损失的元凶 ：务必写一个测试脚本，对比PC端预处理后的张量和设备端预处理后的张量，确保它们之间的差异极小。
• 内存不足的诡异表现 ：内存不足不一定直接崩溃。它可能表现为模型解释器初始化失败、推理结果全零或随机值。始终监控堆内存使用情况（ ESP.getFreeHeap() ）。
• 量化模型的输入输出尺度 ：量化模型通常有输入/输出的零点（zero point）和尺度（scale）。在使用 EloquentTinyML 或纯TF Lite Micro API时，要清楚你提供的输入数据是否需要已经是量化后的值（如int8），以及输出的 predictions 数组如何通过尺度和零点还原为浮点概率。 EloquentTinyML 的 predict 方法通常帮你处理了这些，但如果自己写底层代码，这是必须搞清楚的。
• 摄像头初始化失败 ：ESP32-CAM的引脚配置有多种变体（如AI-THINKER版本）。务必根据你的具体模块型号，在代码中正确配置 camera_config_t 结构体中的 pin 定义。一个错误的引脚定义会导致摄像头无法初始化。

这个项目就像是在螺丝壳里做道场，充满了限制，但也正是这些限制，逼着我们去深入理解AI模型从训练到部署的每一个细节。当你看到那小小的板子，闪烁着灯光，准确地报出“CNY 100”时，那种成就感，是单纯调云API无法比拟的。它不只是一个识别功能，更是一个完整的、在边缘运行的智能感知系统。