---

1. 课前导读

1.1 本节课学习目标

• 理解模型轻量化的必要性：边缘设备资源受限（存储、内存、算力、功耗）。
• 掌握量化的原理：浮点（FP32）到定点（INT8）的映射，以及训练后量化与量化感知训练的区别。
• 掌握剪枝的原理：权重剪枝和结构化剪枝，稀疏训练与掩码更新。
• 掌握知识蒸馏的原理：温度参数、软标签、学生-教师架构。
• 能够使用TensorFlow Model Optimization Toolkit（tfmot）对Keras模型进行量化、剪枝和蒸馏。
• 通过实验对比轻量化后的模型大小、推理速度和精度变化。

1.2 知识重难点

类别	内容
重点	量化映射公式（scale, zero point）；训练后量化 vs 量化感知训练；剪枝的稀疏度调度；知识蒸馏的温度与损失函数
难点	量化中的校准集选择；剪枝中权重重要性评估（幅度剪枝）；蒸馏时教师模型软标签的生成与学生模型的训练策略
易混淆点	权重剪枝 vs 结构化剪枝；训练后动态量化 vs 静态量化；知识蒸馏与迁移学习的区别

1.3 学习前置条件

• 已掌握TensorFlow模型训练和评估（第17课）。
• 了解CNN基本结构（第21-22课）。
• 能够使用Keras API构建模型。

1.4 学完可掌握能力

• 独立将训练好的模型量化为INT8，减小体积4倍以上，加速推理。
• 应用剪枝技术移除不重要的权重，实现模型稀疏化。
• 使用知识蒸馏训练更轻量的学生模型。
• 结合多种技术获得极致压缩的模型。

1.5 行业应用场景

• 移动端AI：手机上的图像分类、物体检测。
• 嵌入式设备：树莓派、Jetson Nano上的实时推理。
• 物联网传感器：低功耗MCU上的关键字识别。
• 云端模型加速：降低推理延迟和成本。

2. 核心理论精讲

2.1 模型轻量化技术概览

技术	原理	压缩比	精度影响	实现难度
量化	降低数值精度（FP32→INT8）	4x	通常<1%	低（训练后量化）
剪枝	移除权重/通道	2-10x	需重训练恢复	中
知识蒸馏	大模型教小模型	10-100x	依赖于师生差异	中

可组合使用：先剪枝，再量化，获得更高压缩比。

2.2 量化原理

线性量化：将浮点数 ( r ) 映射到整数 ( q )：
[
q = \text{round}\left(\frac{r}{\text{scale}} + \text{zero_point}\right)
]
反量化：
[
r = \text{scale} \cdot (q - \text{zero_point})
]

• scale：浮点缩放因子。
• zero_point：整数零点。

训练后量化（Post-Training Quantization）：

• 动态范围量化：仅量化权重，激活动态量化（推理时计算）。
• 全整数量化：权重和激活均量化，需校准集确定激活范围。

量化感知训练（Quantization-Aware Training, QAT）：在训练中模拟量化噪声，使模型适应低精度，精度损失更小。

2.3 剪枝原理

幅度剪枝：移除绝对值小于阈值的权重。通过训练过程中逐步增加稀疏度（如从0%到90%），使模型学习保留重要连接。

结构化剪枝：移除整个滤波器或通道，得到规则稀疏的模型，便于硬件加速。

TensorFlow的tfmot支持权重剪枝：添加prune_low_magnitude包装层，并设置稀疏度调度器。

2.4 知识蒸馏原理

训练一个小模型（学生）模仿一个大模型（教师）的输出。损失函数：
[
\mathcal{L} = \alpha \cdot \mathcal{L}{\text{hard}} + (1-\alpha) \cdot T^2 \cdot \mathcal{L}{\text{soft}}
]

• 硬损失：学生预测与真实标签的交叉熵。
• 软损失：学生与教师软化后的概率分布（通过温度 ( T ) 软化）的KL散度。
• 温度 ( T ) 使概率分布更平滑，传递更多暗知识。

2.5 轻量化流程建议

1. 先训练一个高精度的基准模型（教师）。
2. 对教师模型进行剪枝，再微调恢复精度。
3. 对剪枝后模型进行量化（PTQ或QAT）。
4. 也可用蒸馏训练一个更小架构的学生模型，再量化。

3. 环境搭建与工具配置

conda activate tf213
pip install tensorflow-model-optimization

验证安装：

import tensorflow_model_optimization as tfmot
print(tfmot.__version__)

导入模块：

import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
from tensorflow import keras
from tensorflow.keras import layers, models, datasets
import tensorflow_model_optimization as tfmot
import tempfile
import pathlib

4. 代码实战教学

4.1 训练基准模型（CNN for MNIST）

# 加载MNIST
(x_train, y_train), (x_test, y_test) = datasets.mnist.load_data()
x_train = x_train.reshape(-1, 28, 28, 1).astype(np.float32) / 255.0
x_test = x_test.reshape(-1, 28, 28, 1).astype(np.float32) / 255.0
y_train = tf.keras.utils.to_categorical(y_train, 10)
y_test = tf.keras.utils.to_categorical(y_test, 10)

# 构建简单CNN
def baseline_model():
    model = models.Sequential([
        layers.Conv2D(32, 3, activation='relu', input_shape=(28,28,1)),
        layers.MaxPooling2D(2),
        layers.Conv2D(64, 3, activation='relu'),
        layers.MaxPooling2D(2),
        layers.Flatten(),
        layers.Dense(64, activation='relu'),
        layers.Dense(10, activation='softmax')
    ])
    return model

baseline = baseline_model()
baseline.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])
baseline.fit(x_train, y_train, epochs=5, batch_size=128, validation_split=0.1, verbose=1)
_, baseline_acc = baseline.evaluate(x_test, y_test, verbose=0)
print(f"Baseline test accuracy: {baseline_acc:.4f}")

4.2 训练后量化（动态范围）

# 转换模型为TFLite并进行动态范围量化
converter = tf.lite.TFLiteConverter.from_keras_model(baseline)
converter.optimizations = [tf.lite.Optimize.DEFAULT]  # 默认优化（动态范围量化）
tflite_model = converter.convert()

# 保存并查看大小
with open('baseline_dynamic_quant.tflite', 'wb') as f:
    f.write(tflite_model)
print(f"Dynamic quant model size: {len(tflite_model) / 1024:.2f} KB")

4.3 训练后静态整数量化（需要校准集）

def representative_dataset():
    for i in range(100):
        yield [x_train[i:i+1].astype(np.float32)]

converter = tf.lite.TFLiteConverter.from_keras_model(baseline)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
converter.representative_dataset = representative_dataset
converter.target_spec.supported_ops = [tf.lite.OpsSet.TFLITE_BUILTINS_INT8]
converter.inference_input_type = tf.uint8
converter.inference_output_type = tf.uint8
tflite_int8_model = converter.convert()
with open('baseline_int8.tflite', 'wb') as f:
    f.write(tflite_int8_model)
print(f"INT8 quant model size: {len(tflite_int8_model) / 1024:.2f} KB")

4.4 量化感知训练（QAT）

# 在训练期间模拟量化
qat_model = tfmot.quantization.keras.quantize_model(baseline_model())
qat_model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])
qat_model.fit(x_train, y_train, epochs=3, validation_split=0.1, batch_size=128, verbose=1)
# 转换为TFLite
converter = tf.lite.TFLiteConverter.from_keras_model(qat_model)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
tflite_qat = converter.convert()
print(f"QAT model size: {len(tflite_qat) / 1024:.2f} KB")

4.5 权重剪枝

# 定义剪枝参数
pruning_params = {
    'pruning_schedule': tfmot.sparsity.keras.PolynomialDecay(
        initial_sparsity=0.0,
        final_sparsity=0.5,
        begin_step=1000,
        end_step=2000
    )
}
# 包装模型
pruned_model = tfmot.sparsity.keras.prune_low_magnitude(baseline_model(), **pruning_params)
pruned_model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])
# 添加回调来更新剪枝掩码
callbacks = [tfmot.sparsity.keras.UpdatePruningStep()]
pruned_model.fit(x_train, y_train, epochs=4, validation_split=0.1, callbacks=callbacks, verbose=1)
# 去除剪枝包装，获得最终稀疏模型
stripped_model = tfmot.sparsity.keras.strip_pruning(pruned_model)
# 转换为TFLite（可选量化）
converter = tf.lite.TFLiteConverter.from_keras_model(stripped_model)
tflite_pruned = converter.convert()
print(f"Pruned model size: {len(tflite_pruned) / 1024:.2f} KB")

4.6 知识蒸馏（简单示例）

# 教师模型（较大）
teacher = models.Sequential([
    layers.Conv2D(64, 3, activation='relu', input_shape=(28,28,1)),
    layers.Conv2D(64, 3, activation='relu'),
    layers.MaxPooling2D(2),
    layers.Conv2D(128, 3, activation='relu'),
    layers.MaxPooling2D(2),
    layers.Flatten(),
    layers.Dense(128, activation='relu'),
    layers.Dense(10, activation='softmax')
])
teacher.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])
teacher.fit(x_train, y_train, epochs=5, batch_size=128, validation_split=0.1, verbose=1)
# 学生模型（更小）
student = models.Sequential([
    layers.Conv2D(32, 3, activation='relu', input_shape=(28,28,1)),
    layers.MaxPooling2D(2),
    layers.Flatten(),
    layers.Dense(32, activation='relu'),
    layers.Dense(10, activation='softmax')
])
# 蒸馏训练：使用教师软标签
def distillation_loss(y_true, y_pred, teacher_logits, temperature=3.0, alpha=0.5):
    soft_teacher = tf.nn.softmax(teacher_logits / temperature)
    soft_student = tf.nn.softmax(y_pred / temperature)
    loss_soft = tf.keras.losses.KLDivergence()(soft_teacher, soft_student) * (temperature ** 2)
    loss_hard = tf.keras.losses.categorical_crossentropy(y_true, y_pred)
    return alpha * loss_hard + (1 - alpha) * loss_soft

# 训练时使用教师预测作为额外输入（简化实现略，实际需自定义训练循环）

5. 案例实操演练

案例：在CIFAR-10上应用剪枝+量化，实现模型压缩10倍且精度损失<2%

5.1 加载CIFAR-10并训练基准模型

(x_train, y_train), (x_test, y_test) = datasets.cifar10.load_data()
x_train = x_train.astype(np.float32) / 255.0
x_test = x_test.astype(np.float32) / 255.0
y_train = tf.keras.utils.to_categorical(y_train, 10)
y_test = tf.keras.utils.to_categorical(y_test, 10)

def build_cifar_model():
    model = models.Sequential([
        layers.Conv2D(32, 3, activation='relu', input_shape=(32,32,3)),
        layers.Conv2D(32, 3, activation='relu'),
        layers.MaxPooling2D(2),
        layers.Conv2D(64, 3, activation='relu'),
        layers.Conv2D(64, 3, activation='relu'),
        layers.MaxPooling2D(2),
        layers.Flatten(),
        layers.Dense(128, activation='relu'),
        layers.Dense(10, activation='softmax')
    ])
    return model

model = build_cifar_model()
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])
model.fit(x_train, y_train, epochs=15, batch_size=128, validation_split=0.1, verbose=1)
_, baseline_acc = model.evaluate(x_test, y_test, verbose=0)
print(f"Baseline acc: {baseline_acc:.4f}")

5.2 剪枝训练

pruning_params = {
    'pruning_schedule': tfmot.sparsity.keras.PolynomialDecay(
        initial_sparsity=0.0,
        final_sparsity=0.75,
        begin_step=2000,
        end_step=8000
    )
}
pruned_model = tfmot.sparsity.keras.prune_low_magnitude(build_cifar_model(), **pruning_params)
pruned_model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])
callbacks = [tfmot.sparsity.keras.UpdatePruningStep()]
pruned_model.fit(x_train, y_train, epochs=25, batch_size=128, validation_split=0.1, callbacks=callbacks, verbose=1)
# 去除剪枝包装
stripped = tfmot.sparsity.keras.strip_pruning(pruned_model)
_, pruned_acc = stripped.evaluate(x_test, y_test, verbose=0)
print(f"Pruned acc: {pruned_acc:.4f}")

5.3 量化感知训练（QAT）

quant_model = tfmot.quantization.keras.quantize_model(stripped)
quant_model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])
quant_model.fit(x_train, y_train, epochs=5, batch_size=128, validation_split=0.1, verbose=1)
_, qat_acc = quant_model.evaluate(x_test, y_test, verbose=0)
print(f"QAT acc: {qat_acc:.4f}")

# 转换为TFLite
converter = tf.lite.TFLiteConverter.from_keras_model(quant_model)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
tflite_final = converter.convert()
print(f"Final model size: {len(tflite_final) / 1024:.2f} KB")
# 原始模型大小估算（FP32 权重）约 1.2 MB，压缩后约 100 KB

6. 常见坑点与排错总结

6.1 量化坑点

• 坑1：静态量化时校准集代表性不足，导致精度大幅下降。

  • 解决：校准集应来自训练集或真实场景，覆盖各种输入。

• 坑2：某些算子不支持INT8（如Reshape、Concatenate），模型转换失败。

  • 解决：检查模型结构，使用兼容的算子。

• 坑3：量化感知训练后转换时忘记设置optimizations，实际没有量化。

6.2 剪枝坑点

• 坑4：剪枝开始步数（begin_step）过小，导致模型未充分训练就剪枝。

  • 建议：至少训练1000步后再开始剪枝。

• 坑5：最终稀疏度过高（>90%）导致精度断崖下降。

  • 建议：从50%开始，逐步提高。

• 坑6：剪枝后的模型需要微调以恢复精度，但微调轮次不足。

6.3 知识蒸馏坑点

• 坑7：温度过高导致软标签过度平滑，信息丢失；过低则接近硬标签。

  • 经验：温度通常设为3-5。

• 坑8：学生模型过小，无法学习教师的知识。

  • 解决：增大学生容量或使用中间层提示。

7. 知识点总结 + 课后作业

7.1 核心知识点梳理

• 量化：INT8量化压缩4倍，训练后量化简单，QAT精度更高。
• 剪枝：移除不重要权重，需重训练恢复精度，可结合量化。
• 知识蒸馏：用教师软标签传递知识，训练小模型。
• 工具：tensorflow-model-optimization库提供剪枝、量化API。

7.2 基础作业

1. 对MNIST CNN模型应用训练后动态量化，比较推理时间（使用TFLite Python API）。
2. 调整剪枝最终稀疏度（0.5, 0.75, 0.9），观察精度变化。
3. 使用TensorFlow Hub上的预训练模型，对其进行量化并评估。

7.3 进阶实操作业

任务：组合使用剪枝+量化+蒸馏压缩MobileNetV2用于CIFAR-10

• 使用tf.keras.applications.MobileNetV2作为教师模型（微调后）。
• 设计一个更小的学生模型（如深度可分离卷积）。
• 使用知识蒸馏训练学生模型，然后进行剪枝和量化。
• 最终模型大小压缩10倍以上，精度损失<3%。

7.4 思考拓展题

1. 为什么量化感知训练比训练后量化效果更好？请从梯度更新的角度分析。

2. 剪枝后的稀疏权重格式（如CSR）对推理加速有何影响？硬件加速器（如GPU、TPU）对稀疏性的支持程度如何？

3. 知识蒸馏中，温度参数T与模型输出的“暗知识”有什么关系？如果T=1，蒸馏退化为普通训练，为什么？

---

下一课预告：GPU加速训练配置——我们将学习CUDA和cuDNN的安装与配置、多GPU训练以及混合精度训练，大幅提升模型训练速度。

---

🔗《TensorFlow2.x: 深度学习入门到高阶实战教程》系列课程导航

去订阅

第一部分：基础入门（1-10 课）
第二部分：神经网络核心（11-25 课）
第三部分：进阶网络与框架高阶（26-40 课）
第四部分：企业实战与项目落地（41-50 课）

🌟 感谢您耐心阅读到这里！
💡 如果本文对您有所启发欢迎：
👍 点赞📌 收藏 📤 分享给更多需要的伙伴。
🗣️ 期待在评论区看到您的想法, 共同进步。
🔔 关注我，持续获取更多干货内容～
🤗 我们下篇文章见～