【嵌入式 AI 实战第 2 期】模型轻量化核心技术：量化 / 剪枝 / 蒸馏全解析与 STM32 部署实战

一、为什么嵌入式 AI 必须做模型轻量化？

在嵌入式设备上部署 AI 模型，我们面临的是 **"寸土寸金"** 的资源环境：

• 计算能力有限：主流 Cortex-M4/M7 内核 MCU 主频通常在 80-400MHz，没有专用的 NPU 加速单元
• 内存资源紧张：RAM 通常在几十 KB 到几 MB 之间，Flash 一般在几百 KB 到几十 MB
• 功耗要求严格：电池供电设备需要极低的运行功耗

而一个未经优化的深度学习模型是什么样的呢？以最简单的 MNIST 手写数字识别模型为例，一个包含 2 个隐藏层的 MLP 模型，参数量约为 10 万个，使用 32 位浮点数存储时，仅权重就需要约 400KB 的空间，推理一次需要数百万次浮点运算。这对于很多资源受限的 MCU 来说已经是难以承受的负担，更不用说更复杂的 CNN 或 RNN 模型了。

模型轻量化技术的核心目标就是：在尽可能保持模型精度的前提下，大幅减小模型体积、降低计算复杂度、减少内存占用，让 AI 模型能够在 MCU 上流畅运行。

二、模型轻量化三大核心技术详解

2.1 网络剪枝："剪掉" 模型中的 "赘肉"

网络剪枝的核心思想是：神经网络中存在大量的冗余连接和神经元，它们对最终的预测结果贡献很小甚至没有贡献，可以安全地移除。

剪枝的基本流程

1. 训练一个完整的模型：先在数据集上训练一个高精度的大模型
2. 评估权重重要性：根据一定的标准（如权重的绝对值大小、梯度信息等）评估每个连接或神经元的重要性
3. 剪枝：移除重要性低于某个阈值的连接或神经元
4. 微调：对剪枝后的模型进行微调，恢复因剪枝损失的精度
5. 迭代：重复步骤 2-4，直到达到目标压缩率

剪枝的分类

• 结构化剪枝：移除整个神经元、卷积核或层，剪枝后的模型仍然是规则的，可以直接在现有硬件和框架上运行
• 非结构化剪枝：移除单个权重连接，压缩率更高，但会产生稀疏矩阵，需要特殊的硬件和软件支持才能发挥性能优势

对于嵌入式开发者来说，结构化剪枝是更实用的选择，因为它不需要修改推理引擎，直接就能在 TFLite-Micro 等框架上运行。

2.2 量化压缩：工业界首选的轻量化方案

量化是目前工业界应用最广泛、效果最显著的模型轻量化技术。它的核心思想是：将模型的权重和激活值从高精度的 32 位浮点数 (FP32) 转换为低精度的整数 (如 INT8、UINT8) 甚至二进制 (1 位)。

为什么量化能带来巨大收益？

• 模型体积减小 75%：FP32 转 INT8，每个参数从 4 字节变为 1 字节
• 推理速度提升 2-4 倍：整数运算比浮点运算快得多，且很多 MCU 的硬件对整数运算有专门优化
• 内存占用大幅降低：权重和激活值都使用整数存储，减少了 RAM 和 Flash 的占用
• 功耗显著降低：整数运算单元的功耗远低于浮点运算单元

INT8 对称量化原理详解

INT8 量化是目前最成熟、应用最广泛的量化方案。我们重点讲解对称量化的原理。

量化的本质是一个线性映射过程，将 FP32 的数值范围映射到 INT8 的数值范围 (-128 到 127)。

对称量化公式：

量化值 = round(浮点值 / 缩放因子)
浮点值 = 量化值 * 缩放因子

其中，缩放因子 (Scale) 的计算方式为：

缩放因子 = max(abs(浮点值的最小值), 浮点值的最大值) / 127

对称量化的特点是：

• 没有零点 (Zero Point)，浮点值 0 对应量化值 0
• 计算简单，推理速度快
• 适用于权重的量化，因为权重通常分布在 0 附近

对于激活值，由于其分布通常不是对称的，更多使用非对称量化，引入零点参数：

量化值 = round(浮点值 / 缩放因子 + 零点)
浮点值 = (量化值 - 零点) * 缩放因子

量化的精度损耗

量化本质上是一种信息有损压缩，会带来一定的精度损失。但实践证明，对于大多数深度学习任务，INT8 量化带来的精度损失非常小（通常在 1% 以内），完全可以接受。

2.3 知识蒸馏："老师" 教 "学生"

知识蒸馏是一种将大模型 (教师模型) 的 "知识" 迁移到小模型 (学生模型) 的技术。

知识蒸馏的基本思想

• 训练一个高精度的大模型作为 "教师"
• 让小模型 "学生" 不仅学习真实标签，还学习教师模型输出的 "软标签"
• 软标签包含了教师模型学到的更丰富的信息，能够帮助学生模型达到更高的精度

知识蒸馏的损失函数通常是两部分的加权和：

• 学生模型输出与真实标签的交叉熵损失
• 学生模型输出与教师模型输出的 KL 散度损失

知识蒸馏特别适合与剪枝和量化结合使用，可以有效恢复因模型压缩带来的精度损失。

三、TFLite-Micro：嵌入式端首选推理引擎

TensorFlow Lite for Microcontrollers (TFLite-Micro) 是 Google 专门为微控制器和其他资源受限设备设计的轻量级推理引擎。

3.1 TFLite-Micro 的核心特点

• 极小的内存占用：核心运行时仅占用几十 KB 的 Flash 和几 KB 的 RAM
• 跨平台支持：支持 ARM Cortex-M 系列、ESP32、RISC-V 等多种架构
• 算子支持丰富：支持大多数常用的神经网络算子
• 易于集成：纯 C++ 实现，无依赖，可直接集成到嵌入式项目中

3.2 TFLite-Micro 运行机制详解

TFLite-Micro 的运行流程非常简洁：

1. 模型加载：将量化后的 TFLite 模型文件转换为 C 语言数组，编译到固件中
2. 解释器初始化：创建解释器对象，分配内存缓冲区
3. 输入数据填充：将预处理后的输入数据写入输入张量
4. 模型推理：调用解释器的 Invoke () 方法执行推理
5. 输出结果获取：从输出张量中读取推理结果

3.3 内存缓冲区分配

TFLite-Micro 采用静态内存分配策略，所有内存缓冲区都在初始化时预先分配，运行时不进行任何动态内存分配。这对于嵌入式系统来说至关重要，因为动态内存分配会带来不确定性和内存碎片问题。

TFLite-Micro 需要分配的内存主要包括：

• 模型数据：存储模型的权重和结构信息（通常在 Flash 中）
• 张量缓冲区：存储输入、输出和中间层的激活值（在 RAM 中）
• 解释器状态：存储解释器的运行状态信息（在 RAM 中）

四、全流程实战：MLP 模型训练与 STM32 部署

下面我们通过一个完整的实战案例，演示如何将一个简单的 MLP 模型训练、量化并部署到 STM32 单片机上。

4.1 环境搭建

# 安装必要的Python库
pip install tensorflow numpy matplotlib pandas

4.2 模型训练

我们使用 MNIST 手写数字数据集训练一个简单的 MLP 模型。

import tensorflow as tf
from tensorflow.keras import layers, models

# 加载MNIST数据集
(x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data()

# 数据预处理
x_train = x_train.reshape(-1, 784).astype('float32') / 255.0
x_test = x_test.reshape(-1, 784).astype('float32') / 255.0

# 构建MLP模型
model = models.Sequential([
    layers.Dense(128, activation='relu', input_shape=(784,)),
    layers.Dense(64, activation='relu'),
    layers.Dense(10, activation='softmax')
])

# 编译模型
model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

# 训练模型
model.fit(x_train, y_train, epochs=10, batch_size=32, validation_split=0.1)

# 评估模型
test_loss, test_acc = model.evaluate(x_test, y_test)
print(f'测试精度: {test_acc:.4f}')

# 保存模型
model.save('mnist_mlp.h5')

4.3 模型转换与 INT8 量化

将训练好的 Keras 模型转换为 TFLite 格式，并进行 INT8 量化。

# 加载模型
model = tf.keras.models.load_model('mnist_mlp.h5')

# 转换为TFLite格式
converter = tf.lite.TFLiteConverter.from_keras_model(model)

# 启用INT8量化
converter.optimizations = [tf.lite.Optimize.DEFAULT]

# 定义校准数据生成器
def representative_data_gen():
    for input_value in tf.data.Dataset.from_tensor_slices(x_train).batch(1).take(100):
        yield [input_value]

converter.representative_dataset = representative_data_gen
converter.target_spec.supported_ops = [tf.lite.OpsSet.TFLITE_BUILTINS_INT8]
converter.inference_input_type = tf.int8
converter.inference_output_type = tf.int8

# 转换并保存量化后的模型
tflite_model_quant = converter.convert()
with open('mnist_mlp_quantized.tflite', 'wb') as f:
    f.write(tflite_model_quant)

# 打印模型大小
print(f'浮点模型大小: {len(model.to_json()) + model.count_params() * 4 / 1024:.2f} KB')
print(f'量化模型大小: {len(tflite_model_quant) / 1024:.2f} KB')

4.4 生成 C 语言数组

使用 xxd 工具将 TFLite 模型文件转换为 C 语言数组：

xxd -i mnist_mlp_quantized.tflite > model_data.h

4.5 STM32 部署

1. 创建一个新的 STM32 项目，添加 TFLite-Micro 库
2. 将生成的model_data.h文件添加到项目中
3. 编写推理代码：

#include "tensorflow/lite/micro/all_ops_resolver.h"
#include "tensorflow/lite/micro/micro_interpreter.h"
#include "tensorflow/lite/schema/schema_generated.h"
#include "model_data.h"
#include "stm32f4xx_hal.h"  // 根据你的MCU型号修改，如stm32f1xx_hal.h、stm32h7xx_hal.h等

// 定义内存缓冲区大小（根据模型实际需求调整）
const int tensor_arena_size = 10 * 1024;
uint8_t tensor_arena[tensor_arena_size];

// 全局变量
const tflite::Model* model = nullptr;
tflite::MicroInterpreter* interpreter = nullptr;
TfLiteTensor* input = nullptr;
TfLiteTensor* output = nullptr;

// 串口句柄（全局变量，供printf重定向使用）
UART_HandleTypeDef huart1;

/**
 * @brief  系统时钟配置
 * @note   这里以STM32F407为例，配置为168MHz系统时钟
 *         其他型号MCU请根据实际情况修改
 */
void SystemClock_Config(void) {
  RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

  // 配置HSE振荡器
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
  RCC_OscInitStruct.HSEState = RCC_HSE_ON;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
  RCC_OscInitStruct.PLL.PLLM = 8;
  RCC_OscInitStruct.PLL.PLLN = 336;
  RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;
  RCC_OscInitStruct.PLL.PLLQ = 7;
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK) {
    Error_Handler();
  }

  // 配置系统时钟、AHB和APB总线时钟
  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
                              |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV4;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV2;

  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_5) != HAL_OK) {
    Error_Handler();
  }
}

/**
 * @brief  USART1初始化函数
 * @param  baudrate: 波特率，如115200
 */
void MX_USART1_UART_Init(uint32_t baudrate) {
  huart1.Instance = USART1;
  huart1.Init.BaudRate = baudrate;
  huart1.Init.WordLength = UART_WORDLENGTH_8B;
  huart1.Init.StopBits = UART_STOPBITS_1;
  huart1.Init.Parity = UART_PARITY_NONE;
  huart1.Init.Mode = UART_MODE_TX_RX;
  huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
  huart1.Init.OverSampling = UART_OVERSAMPLING_16;
  if (HAL_UART_Init(&huart1) != HAL_OK) {
    Error_Handler();
  }
}

/**
 * @brief  UART MSP初始化回调函数
 * @param  huart: UART句柄指针
 */
void HAL_UART_MspInit(UART_HandleTypeDef* huart) {
  GPIO_InitTypeDef GPIO_InitStruct = {0};
  
  if (huart->Instance == USART1) {
    // 使能USART1和GPIOA时钟
    __HAL_RCC_USART1_CLK_ENABLE();
    __HAL_RCC_GPIOA_CLK_ENABLE();

    // 配置USART1 TX引脚(PA9)和RX引脚(PA10)
    GPIO_InitStruct.Pin = GPIO_PIN_9|GPIO_PIN_10;
    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
    GPIO_InitStruct.Alternate = GPIO_AF7_USART1;
    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
  }
}

/**
 * @brief  错误处理函数
 */
void Error_Handler(void) {
  // 死循环，点亮LED指示错误（如果有LED的话）
  while (1) {
    // HAL_GPIO_TogglePin(GPIOA, GPIO_PIN_5); // 例如PA5连接LED
    // HAL_Delay(500);
  }
}

/**
 * @brief  printf重定向到USART1
 */
#ifdef __GNUC__
int __io_putchar(int ch) {
#else
int fputc(int ch, FILE *f) {
#endif
  HAL_UART_Transmit(&huart1, (uint8_t *)&ch, 1, HAL_MAX_DELAY);
  return ch;
}

/**
 * @brief  模型初始化函数
 */
void Model_Init(void) {
  // 加载模型
  model = tflite::GetModel(mnist_mlp_quantized_tflite);
  
  // 检查模型版本
  if (model->version() != TFLITE_SCHEMA_VERSION) {
    printf("模型版本不匹配！期望版本: %d, 实际版本: %d\r\n",
           TFLITE_SCHEMA_VERSION, model->version());
    Error_Handler();
  }
  
  // 注册所有算子
  static tflite::AllOpsResolver resolver;
  
  // 创建解释器
  static tflite::MicroInterpreter static_interpreter(
      model, resolver, tensor_arena, tensor_arena_size);
  interpreter = &static_interpreter;
  
  // 分配张量内存
  TfLiteStatus allocate_status = interpreter->AllocateTensors();
  if (allocate_status != kTfLiteOk) {
    printf("张量内存分配失败！错误码: %d\r\n", allocate_status);
    Error_Handler();
  }
  
  // 获取输入输出张量指针
  input = interpreter->input(0);
  output = interpreter->output(0);
  
  printf("模型初始化成功！\r\n");
  printf("输入张量形状: %d x %d\r\n", input->dims->data[0], input->dims->data[1]);
  printf("输出张量形状: %d x %d\r\n", output->dims->data[0], output->dims->data[1]);
}

/**
 * @brief  主函数
 */
int main(void) {
  // 初始化HAL库
  HAL_Init();
  
  // 配置系统时钟
  SystemClock_Config();
  
  // 初始化USART1，波特率115200
  MX_USART1_UART_Init(115200);
  
  // 初始化TFLite-Micro模型
  Model_Init();
  
  // 主循环
  while (1) {
    // 这里添加图像采集和预处理代码
    // 为了演示，我们使用测试集中的一张图片
    // uint8_t test_image[784] = { ... }; // 你的测试图像数据
    
    // 填充输入数据（注意INT8量化的偏移：0-255 -> -128-127）
    for (int i = 0; i < 784; i++) {
      input->data.int8[i] = (int8_t)(test_image[i] - 128);
    }
    
    // 执行推理
    uint32_t start_time = HAL_GetTick();
    TfLiteStatus invoke_status = interpreter->Invoke();
    uint32_t inference_time = HAL_GetTick() - start_time;
    
    if (invoke_status != kTfLiteOk) {
      printf("推理执行失败！错误码: %d\r\n", invoke_status);
      continue;
    }
    
    // 解析输出结果
    int predicted_digit = 0;
    int8_t max_score = -128;
    for (int i = 0; i < 10; i++) {
      if (output->data.int8[i] > max_score) {
        max_score = output->data.int8[i];
        predicted_digit = i;
      }
    }
    
    // 打印结果和推理耗时
    printf("预测数字: %d, 推理耗时: %d ms\r\n", predicted_digit, inference_time);
    
    // 延时1秒
    HAL_Delay(1000);
  }
}

五、性能对比测试

我们在 STM32F407 单片机上对浮点模型和量化模型进行了性能测试，结果如下：

从测试结果可以看出：

• INT8 量化将模型体积减小了 75%，完全符合预期
• 推理速度提升了近 4 倍，这对于实时应用来说至关重要
• 精度损失仅为 0.26%，几乎可以忽略不计

这充分证明了 INT8 量化在嵌入式 AI 部署中的巨大价值。

六、总结

本期我们系统性地学习了模型轻量化的三大核心技术：网络剪枝、量化压缩和知识蒸馏。其中，INT8 量化因其实现简单、效果显著，成为了工业界嵌入式 AI 部署的首选方案。

我们通过一个完整的实战案例，演示了从模型训练、量化到 STM32 部署的全流程。实测结果表明，INT8 量化能够在几乎不损失精度的前提下，将模型体积减小 75%，推理速度提升 4 倍，完全满足嵌入式设备的要求。

在实际项目中，我们可以根据具体需求，将这三种技术结合使用，以达到最佳的压缩效果。例如，可以先对模型进行剪枝，然后进行量化，最后再用知识蒸馏恢复精度。

七、下期预告

下期专题：第 3 期《离线语音识别：音频采集与 MFCC 特征提取》

下期我们将开启实战应用模块，聚焦最常用的嵌入式 AI 应用之一 —— 离线语音识别。我们将深入讲解：

• 数字麦克风的工作原理与硬件连接
• 音频信号的时域波形与频域分析
• FFT 快速傅里叶变换的工程实现
• MFCC 梅尔频率倒谱系数的提取逻辑

我们将基于 ESP32 开发板搭配 INMP441 数字麦克风，完成环境噪声和关键词语音的采集，制作专属的语音数据集，为下一期训练离线语音识别模型做好数据准备。