让大模型跑在小芯片上：边缘 AI 推理的工程挑战与系统级优化路径

一、算力鸿沟：大模型参数量与边缘芯片资源的数量级差距

大模型的参数量以十亿、百亿计，而边缘芯片的资源以 KB、MB 计。这个数量级差距是边缘 AI 推理面临的最根本挑战。一颗 STM32H7 系列 MCU 拥有 1MB SRAM 和 2MB Flash，而一个 INT8 量化的 BERT-Base 模型需要约 110MB 存储空间——即使只部署模型的一个层，也可能超出 MCU 的寻址能力。

但这并不意味着边缘 AI 是不可能的任务。关键在于重新定义"大模型"在边缘端的形态：不是把完整的 GPT 级模型塞进 MCU，而是将特定任务的小型化模型（如 MobileBERT、TinyLlama 的蒸馏版本）通过系统级优化，适配到资源受限的硬件上。这个过程涉及模型压缩、算子融合、内存复用、调度优化等多个工程环节，每一个环节都需要在精度、速度和资源之间做出精确的权衡。

二、边缘 AI 推理的系统架构：从模型到硬件的完整映射链路

边缘 AI 推理不是简单的"模型量化 + 部署"，而是一条从模型优化到硬件映射的完整工程链路。每个环节的输出都是下一个环节的输入，任何一环的效率损失都会在后续被放大。

graph LR
    subgraph 模型优化层
        A[原始模型<br/>FP32/FP16] --> B[训练后量化<br/>INT8/INT4]
        B --> C[结构化剪枝<br/>移除冗余通道]
        C --> D[知识蒸馏<br/>大模型→小模型]
    end

    subgraph 算子编译层
        D --> E[算子融合<br/>Conv+BN+ReLU→单算子]
        E --> F[内存规划<br/>激活值复用/In-place]
        F --> G[指令调度<br/>DMA预取/双缓冲]
    end

    subgraph 硬件执行层
        G --> H[权重分片加载<br/>Flash→SRAM 流式]
        H --> I[计算引擎<br/>CMSIS-NN/自定义加速]
        I --> J[后处理输出<br/>结果解码/NMS]
    end

    subgraph 资源约束
        K[SRAM: 512KB<br/>Flash: 2MB<br/>主频: 480MHz]
    end

    K -.->|约束| H
    K -.->|约束| I

模型优化层的目标是在可接受的精度损失范围内，将模型体积压缩到硬件可承载的范围。训练后量化（PTQ）是最直接的手段，将 FP32 权重转换为 INT8，模型体积直接缩小 4 倍。但 INT8 量化并非万能——某些对精度敏感的层（如注意力机制的 Softmax）需要保留 FP16 精度，混合精度量化是更实际的选择。

算子编译层的目标是减少内存访问次数和计算冗余。算子融合将连续的 Conv-BN-ReLU 合并为单个算子，避免中间结果的内存写入和读取。内存规划通过分析计算图的生命周期，复用不再需要的激活值缓冲区，将峰值内存占用降低 30%—50%。

硬件执行层解决的是模型如何在实际硬件上高效运行的问题。最关键的优化是权重分片加载：由于 SRAM 容量有限，无法一次性加载所有权重，需要将权重按层分片存储在 Flash 中，推理时通过 DMA 将当前层的权重预取到 SRAM，同时计算上一层的输出。这种"计算-加载"双缓冲策略，将内存等待时间隐藏在计算时间中。

三、边缘 AI 推理系统的代码实现

以下代码展示如何在 ARM Cortex-M 环境下实现一个带双缓冲权重加载的推理引擎框架。

#include <stdint.h>
#include <string.h>
#include "stm32h7xx_hal.h"

// 推理引擎配置
#define SRAM_SIZE       (512 * 1024)    // 512KB SRAM
#define FLASH_BASE_ADDR 0x08000000      // Flash 起始地址
#define DMA_CHANNEL     DMA1_Stream0    // DMA 通道
#define MAX_LAYERS      32              // 最大网络层数

// 层描述符：记录每层的元信息
typedef struct {
    uint32_t weight_offset;     // 权重在 Flash 中的偏移地址
    uint32_t weight_size;       // 权重大小（字节）
    uint32_t input_size;        // 输入激活值大小
    uint32_t output_size;       // 输出激活值大小
    uint8_t  quant_bits;        // 量化位数（8 或 16）
    void (*compute_fn)(const int8_t* input, const int8_t* weight,
                       int8_t* output, uint32_t len);  // 计算函数指针
} LayerDescriptor;

// 推理引擎上下文
typedef struct {
    LayerDescriptor layers[MAX_LAYERS];
    uint8_t  num_layers;

    // 双缓冲区：交替用于 DMA 加载和计算
    int8_t* weight_buf_a;       // 权重缓冲区 A
    int8_t* weight_buf_b;       // 权重缓冲区 B
    int8_t* activation_buf;     // 激活值缓冲区（输入/输出复用）
    int8_t* scratch_buf;        // 临时计算缓冲区

    volatile uint8_t dma_complete;  // DMA 传输完成标志
} InferenceEngine;

// DMA 传输完成回调
void HAL_DMA_Callback(DMA_HandleTypeDef *hdma) {
    // 仅设置标志，不在中断中做计算
    extern InferenceEngine g_engine;
    g_engine.dma_complete = 1;
}

// 异步加载权重到 SRAM（通过 DMA）
static void load_weight_async(InferenceEngine* engine,
                               uint32_t layer_idx,
                               int8_t* target_buf) {
    LayerDescriptor* layer = &engine->layers[layer_idx];
    uint32_t src_addr = FLASH_BASE_ADDR + layer->weight_offset;

    engine->dma_complete = 0;
    HAL_DMA_Start_IT(&hdma_dma1_stream0,
                     src_addr,
                     (uint32_t)target_buf,
                     layer->weight_size / 4);  // 按 word 传输
}

// 逐层推理：双缓冲策略隐藏 DMA 延迟
int32_t engine_infer(InferenceEngine* engine, const int8_t* input, int8_t* output) {
    int8_t* current_weight = engine->weight_buf_a;
    int8_t* next_weight    = engine->weight_buf_b;
    int8_t* current_act    = engine->activation_buf;

    // 预加载第 0 层权重
    load_weight_async(engine, 0, current_weight);
    while (!engine->dma_complete) { /* 等待 DMA 完成 */ }

    for (uint8_t i = 0; i < engine->num_layers; i++) {
        LayerDescriptor* layer = &engine->layers[i];

        // 如果不是最后一层，预加载下一层权重到备用缓冲区
        if (i + 1 < engine->num_layers) {
            load_weight_async(engine, i + 1, next_weight);
        }

        // 执行当前层计算（与下一层 DMA 加载并行）
        layer->compute_fn(current_act, current_weight,
                          (i == engine->num_layers - 1) ? output : current_act,
                          layer->output_size);

        // 等待下一层 DMA 完成
        if (i + 1 < engine->num_layers) {
            while (!engine->dma_complete) { /* 自旋等待 */ }
        }

        // 交换缓冲区指针
        int8_t* tmp = current_weight;
        current_weight = next_weight;
        next_weight = tmp;
    }

    return 0;
}

四、边缘推理的代价：精度损失、开发成本与生态碎片化

边缘 AI 推理的每一步优化都伴随着代价，这些代价往往被"模型跑起来了"的喜悦所掩盖。

量化带来的精度损失。INT8 量化通常带来 1%—3% 的精度下降，INT4 量化可能带来 5%—10% 的下降。对于分类任务，这个损失尚可接受；但对于检测任务中的小目标，量化后的模型可能完全丢失对小目标的检测能力。混合精度量化可以缓解这个问题，但增加了部署复杂度——不同精度的层需要不同的计算内核。

开发成本与可维护性。边缘推理引擎需要针对特定硬件平台进行深度优化，CMSIS-NN 库针对 Cortex-M 提供了基础算子，但自定义算子仍需手写汇编。这意味着每更换一款芯片，都可能需要重新优化关键路径。与云端推理的"一次开发、到处部署"相比，边缘推理的开发成本显著更高。

生态碎片化。ARM Cortex-M、RISC-V、ESP32 等不同架构各有自己的推理框架（TFLite Micro、NCNN、ONNX Micro Runtime），模型格式和算子支持不统一。一个在 STM32 上调优好的模型，迁移到 ESP32 上可能需要重新量化、重新编译。

适用边界。边缘 AI 推理适用于对延迟、功耗、隐私有严格要求的场景（工业检测、智能家居、可穿戴设备）。对于计算密集型任务（大语言模型推理、高分辨率图像生成），边缘设备的算力仍然不足，云端推理或云边协同是更现实的选择。

五、总结

让大模型跑在小芯片上，不是简单的模型压缩，而是一条从模型优化、算子编译到硬件执行的完整工程链路。训练后量化压缩模型体积，算子融合减少内存访问，双缓冲策略隐藏加载延迟——每个环节都在精度、速度和资源之间做精确权衡。边缘 AI 推理的代价同样不可忽视：量化精度损失、平台特化开发成本、生态碎片化都是落地的现实障碍。选择边缘部署时，应首先确认业务场景的硬约束（延迟、功耗、隐私），再评估模型压缩后的精度是否满足需求，最后才进入具体的工程优化阶段。