想象一下，你之前住在一栋三层别墅里，烤箱、双门冰箱、十人餐桌一应俱全——这就是云端的 GPU 集群，跑着动辄几十亿参数的大模型。现在，你要把这套“智能管家”搬进树莓派、智能门锁，甚至一颗纽扣电池供电的传感器里，也就是 IoT 设备。听起来像天方夜谭，对吗？但工程实践的本质，就是一门“搬家”的艺术。 本文要教你一套完整的搬家术：先用卷尺量清新公寓的尺寸（算力、内存、功耗），再用真空压缩袋把模型体积压到原来的四分之一、八分之一（量化），顺手断舍离掉一年用不上的旧物（裁剪），挑选合适的收纳家具最大化空间利用率（推理引擎），精打细算水电费让电池撑得更久（功耗优化），最后按照流程单验收、长期维护（部署验证）。这套方法论，正是 SLM（小语言模型）在 IoT 设备上的完整部署指南。掌握它，你就从“只会训模型”升级为“能把模型塞进任何角落”的实战型工程师。

岗位关联

学会这套部署方法，你就能在资源受限的边缘设备上落地智能语音、异常检测等 AI 应用，成为既懂模型又懂硬件的稀缺型工程人才。

目录
  1. 可视化演示
  2. 1. 部署挑战分析：先量新家尺寸
  3. 2. 量化压缩技术：真空压缩袋
  4. 3. 模型裁剪压缩：搬家断舍离
  5. 4. 推理引擎选型：挑选收纳家具
  6. 5. 功耗性能优化：精打细算电费
  7. 6. 部署验证流程：一次有验收的搬家
  8. AI 应用场景
  9. Python 演示
  10. 常见误区
  11. 面试题

可视化演示

展示SLM模型在IoT设备网络中的部署过程，实时呈现设备算力、内存与功耗约束下的推理调度与动态功耗管理。

本节配有交互动效（进入视口后自动加载，约 3KB）。

全速运行模式 所有IoT设备全速运行SLM推理任务 功耗较高但延迟最低 P∝f³, f=1GHz 适合实时性要求高的场景

1. 部署挑战分析：先量新家尺寸

搬家清单永远从量尺寸开始。你不可能在不知道门宽的情况下，把一张两米宽的红木餐桌搬进一居室。云端的大模型就像别墅里的豪华厨房，而 IoT 设备——树莓派、智能门锁、太阳能传感器——则是一间只有八平方米的小公寓。动手之前，我们得先量清楚：这间公寓到底哪里最挤。

工程师通常盯着三个“门框”：算力、内存、功耗。算力是每秒能做多少次运算，决定推理速度的底线；内存是能同时放下多少东西；功耗则是电表转得有多快，直接决定设备撑一天还是一年。云端一张 A100 显卡有 312 TFLOPS 算力和 80GB 显存，而一块树莓派 4 只有约 0.2 TFLOPS、4GB 内存，更别提只有几百 KB 内存的 MCU 单片机。差距不是一倍两倍，而是两三个数量级。

第一个要算的账，是模型光“住下来”需要多大空间：

量完尺寸，结论通常很残酷：FP32 的 7B 模型要 28GB，普通设备连门都进不去。而且推理时实际开销往往是模型大小的 2~3 倍（还要加上激活值、KV 缓存和运行时开销）。于是我们不得不开始打包——而打包的第一件武器，就是真空压缩袋。

Mmodel=Nparams×b8 Bytes\displaystyle M_{model} = \frac{N_{params} \times b}{8}\ \text{Bytes}
模型占用内存 = 参数量 × 每个参数比特数 ÷ 8。把 70 亿参数代进去算一算，就知道为什么必须压缩了。
  1. 参数量 N模型中所有权重和偏置的总个数。7B 模型就是 N = 70 亿。
    N=7×109\displaystyle N = 7 \times 10^{9}
  2. 位宽 b每个参数用几个比特存储。FP32 的 b = 32，INT8 的 b = 8，INT4 的 b = 4。
    b∈{32, 8, 4}\displaystyle b \in \{32,\ 8,\ 4\}
  3. 除以 8把“比特”换算成“字节”。1 字节 = 8 比特，所以内存单位是字节。
    1 Byte=8 bits\displaystyle 1\ \text{Byte} = 8\ \text{bits}
  4. 代入计算7B × 32 ÷ 8 ≈ 28GB；若 b = 8，则只需约 7GB；若 b = 4，仅约 3.5GB。
    M=7×109×328≈28 GB\displaystyle M = \frac{7 \times 10^{9} \times 32}{8} \approx 28\ \text{GB}

2. 量化压缩技术：真空压缩袋

搬家时最神奇的工具是真空压缩袋。蓬松的羽绒服抽掉空气后变成一张薄片，体积缩小七八成，保暖效果却几乎不变。量化就是模型世界的真空压缩袋：它不改变模型的层数和结构，只改变每个权重数值的“存储精度”。

原始模型每个权重用 32 位浮点数（FP32）存储，就像羽绒服里充满空气。量化的思路是：既然大部分权重数值集中在一个不大的区间，那我们就用一个更省空间的“刻度尺”来记录它们。把权重从 FP32 压到 INT8，内存立刻缩到四分之一；压到 INT4，就是八分之一。这就是为什么“量化”永远是端侧部署的第一优先级。

最常见的对称量化做法，是找一个缩放比例尺 scale，把浮点区间 [-max, max] 映射到整数的 [-127, 127]：

真空压缩袋也不是万能的，压得太狠会“起皱”。INT4 虽然省地方，但精度损失明显，通常需要量化感知训练（QAT）来补偿；训练后量化（PTQ）则更简单，拿一小部分校准数据统计范围即可。如果某些关键算子特别敏感，还可以保留 FP16——这就叫混合精度，相当于容易皱的羊绒衫单独手洗，不塞进压缩袋。

s=xmax−xmin2b−1,xq=round⁡(xs)+z\displaystyle s = \frac{x_{max} - x_{min}}{2^{b} - 1}, \qquad x_{q} = \operatorname{round}\left(\frac{x}{s}\right) + z
scale 决定“每一格刻度代表多少”，x_q 是把浮点值换算到整数刻度后的结果。量化就是“换一把更粗的尺子量体重”。
  1. 找范围遍历权重张量，找到所有数值的最大值和最小值，确定需要覆盖的区间。
    [xmin, xmax]\displaystyle [x_{min},\ x_{max}]
  2. 定比例尺区间跨度除以量化等级数。b 比特一共能表示 2^b 个整数，所以档位数是 2^b − 1。
    s=xmax−xmin2b−1\displaystyle s = \frac{x_{max} - x_{min}}{2^{b} - 1}
  3. 换算整数每个浮点值除以 scale 后四舍五入，得到最接近的整数刻度，这一步是有损的根源。
    xq=round⁡(xs)\displaystyle x_{q} = \operatorname{round}\left(\frac{x}{s}\right)
  4. 零点偏移非对称量化时，浮点 0 未必正好落在整数 0 上，需要加一个偏移 z 对齐。对称量化则固定 z = 0。
    z=−round⁡(xmins)−xmin\displaystyle z = -\operatorname{round}\left(\frac{x_{min}}{s}\right) - x_{min}

3. 模型裁剪压缩：搬家断舍离

搬家是检验“这东西一年用不上一次”的最佳时机。那个积灰的豆浆机、三套只用过一次的餐具，统统可以断舍离。模型也一样：现代神经网络的权重里，有大量数值接近零的连接，它们在推理时几乎不贡献任何输出。剪枝（Pruning）就是把这些“吃灰旧物”挑出来扔掉。

剪枝分两种风格。非结构化剪枝：把零散的权重值逐个清零，得到一堆“东缺一个西缺一个”的稀疏矩阵；结构化剪枝：干脆把整行整列（channel 或 filter）删掉，就像直接扔掉整套不常用的茶具，保持了家具摆放的规整。除此之外还有知识蒸馏——让大模型当老师，小模型当学生，模仿老师的输出，相当于把老师傅的菜谱精华浓缩成一张速查卡。

剪枝的力度用稀疏度来衡量：

断舍离的度要把握精准。非结构化剪枝虽然稀疏度高，但通用 CPU/GPU 计算不规则稀疏矩阵时需要查表跳过，反而更慢；结构化剪枝牺牲一点稀疏度，换来硬件可以直接跳过的规整形状。裁剪之后，通常还要做少量微调让模型“缓过来”，就像搬家后重新布置家具、让动线恢复流畅。

λ=NprunedNtotal×100%\displaystyle \lambda = \frac{N_{pruned}}{N_{total}} \times 100\%
稀疏度 = 被剪掉的参数个数 ÷ 总参数个数。它告诉你这间屋子到底腾出了多少空间。
  1. 统计总数先数清楚模型一共有多少个参数。
    Ntotal=∑l∣Wl∣\displaystyle N_{total} = \sum_{l} \left| W_{l} \right|
  2. 标记目标根据权重绝对值大小排序，把绝对值低于阈值的连接判定为“可剪”。
    ∣wi∣<τ⇒prune\displaystyle \left| w_{i} \right| < \tau \Rightarrow \text{prune}
  3. 执行剪除把被剪参数置零，统计实际剪掉的数量。
    Npruned=∑i1(wi=0)\displaystyle N_{pruned} = \sum_{i} \mathbb{1}\left( w_{i} = 0 \right)
  4. 计算稀疏度两者相除乘 100%，得到压缩比例的直观数字。剪 30% 往往无感，剪到 70% 可能“厨房变废墟”。
    λ=NprunedNtotal×100%\displaystyle \lambda = \frac{N_{pruned}}{N_{total}} \times 100\%

4. 推理引擎选型：挑选收纳家具

同样是八平方米的房间，用宜家的成品柜还是找师傅定制榻榻米，居住体验天差地别。推理引擎就是模型世界的“收纳设计师”——它不改变模型内容，但通过调度和优化，决定同样的模型在你的设备上跑多快、占多少内存。

业界常用的端侧引擎各有专长：llama.cpp 在手机和树莓派上生态成熟；TensorFlow Lite 对 MCU 友好；MNN 在移动端优化激进；ONNX Runtime 则擅长做各种格式的“翻译官”。引擎主要在三个层面发力：算子融合——把多个小运算合并成一个大运算，减少数据搬运次数；内存布局优化——用定制化的张量排布提升缓存命中率；硬件加速调度——把合适的算子派发给 NPU、DSP 或 GPU。

选引擎之前，先判断瓶颈卡在哪。一个常用的估算公式：

收纳师手艺的好坏，直接决定厨房动线顺不顺。同样一个 INT4 模型，选对引擎、开对优化开关，首 token 延迟可能从几秒降到几百毫秒。实践中的做法是先跑一遍基准测试，对比各引擎在目标硬件上的实测数据，而不是看广告选美。

L=max⁡(PtotalFpeak, MweightsBmem)\displaystyle L = \max\left( \frac{P_{total}}{F_{peak}},\ \frac{M_{weights}}{B_{mem}} \right)
单 token 延迟 ≈ 计算时间和权重复制时间中的较大者。如果算力充裕但内存带宽小，模型再小也快不起来。
  1. 统计计算量模型跑一次推理需要的总运算次数，单位是 FLOPs。
    Ptotal=2×Nparams×Ntokens\displaystyle P_{total} = 2 \times N_{params} \times N_{tokens}
  2. 算计算时间总计算量除以设备峰值算力，得到“一直在算”需要多久。
    Tcompute=PtotalFpeak\displaystyle T_{compute} = \frac{P_{total}}{F_{peak}}
  3. 算搬运时间推理要逐层读取权重，权重总字节数除以内存带宽，就是“光搬数据”需要多久。
    Tmemory=MweightsBmem\displaystyle T_{memory} = \frac{M_{weights}}{B_{mem}}
  4. 取最大值两者谁大，谁就是瓶颈。算力贵的设备选重算子融合；带宽小的设备优先做量化减重。
    L=max⁡(Tcompute, Tmemory)\displaystyle L = \max\left( T_{compute},\ T_{memory} \right)

5. 功耗性能优化：精打细算电费

小公寓最痛的账单是电费。IoT 设备往往靠电池供电，一颗纽扣电池的容量可能只有几百毫瓦时，而云端大模型做一次推理耗的电，够它跑一整天。所以功耗优化不是锦上添花，而是生死线。

硬件层面最有效的招数是动态调频调压（DVFS）。芯片的功耗和电压、频率的关系是：

软件层面同样有大量“抠电”技巧：流式对话场景用 batch = 1 逐 token 生成，避免大批量带来的内存峰值；KV 缓存复用让已算过的历史键值不再重复计算；空闲时让芯片进入休眠状态，把静态功耗压到近乎为零。功耗优化往往是一个个细节叠出来的：一次缓存命中、一次 DVFS 调频、一段低功耗睡眠，加起来就是整块电池的续航时长。

Pdynamic=α⋅C⋅VDD2⋅f\displaystyle P_{dynamic} = \alpha \cdot C \cdot V_{DD}^{2} \cdot f
动态功耗 = 活动因子 × 负载电容 × 电压平方 × 频率。电压在平方项上，所以“降一点电压”比“降一点频率”划算得多。
  1. 活动因子 α一个时钟周期内晶体管发生翻转的比例。计算密集时高，空闲时低。
    0<α≤1\displaystyle 0 < \alpha \le 1
  2. 负载电容 C芯片内部导线和晶体管栅极的等效电容，属于芯片工艺决定的“底数”。
    C=Cwire+Cgate\displaystyle C = C_{wire} + C_{gate}
  3. 电压平方电压从 1.0V 降到 0.8V，功耗直接降到原来的 64%，这是 DVFS 最大的红利来源。
    VDD2=0.82=0.64\displaystyle V_{DD}^{2} = 0.8^{2} = 0.64
  4. 频率 f频率与功耗线性相关，降频能省电，但会拖慢推理，所以要和延迟目标做权衡。
    f∝Pdynamic\displaystyle f \propto P_{dynamic}

6. 部署验证流程：一次有验收的搬家

靠谱的搬家公司都有一张流程单：装箱、搬运、归位、验收、售后。把 SLM 部署到 IoT 设备同样是一条严谨的流水线，每一步都有明确的输入和输出，缺一不可。

第一步是模型转换：把 PyTorch 或 ONNX 格式的模型，转成目标引擎的格式，同时把量化、剪枝的成果固化进去，例如转成 TFLite 的 INT8 模型。第二步是精度验证：用一份固定的验证集，对比 FP32 原模型和部署后模型的输出差异，指标包括困惑度（Perplexity）和任务准确率。第三步是性能基准：实测 tokens/s、首 token 延迟、内存峰值和平均功耗，和预算目标逐项核对。第四步是 OTA 升级：通过灰度发布把新模型推送到设备，出现问题立即回滚。

精度验证的验收标准可以写成：

一套合格的搬家流程，能让“入住体验”可量化、可追踪。部署上线不是终点，而是设备端 AI 生命周期的开始——输入分布会漂移、设备碎片化问题会暴露、算法会迭代，只有把验证和 OTA 机制建好，这份“智能管家”才能在小公寓里长期安稳地住下去。

ΔA=AFP32−Adeployed≤Δtol\displaystyle \Delta A = A_{FP32} - A_{deployed} \le \Delta_{tol}
部署后模型相比原模型的精度下降，必须控制在一个预设容忍范围内。超过红线，就要回头调整量化或剪枝策略。
  1. 取原模型指标用验证集测出 FP32 版本的准确率，作为“搬家前的房间照片”。
    AFP32\displaystyle A_{FP32}
  2. 测部署版指标在设备端用同一份验证集，测出量化裁剪后模型的准确率。
    Adeployed\displaystyle A_{deployed}
  3. 算精度差两者相减，得到部署引入的精度损失。注意用同一份数据，否则对比不公平。
    ΔA=AFP32−Adeployed\displaystyle \Delta A = A_{FP32} - A_{deployed}
  4. 对照容忍线设置经验阈值 Δ_tol（通常 1% ~ 2%），超了就回炉重新调优。
    ΔA≤Δtol\displaystyle \Delta A \le \Delta_{tol}

AI 应用场景

智能门锁的离线语音助理

阶段：模型部署与推理优化

解决的问题：传统云语音方案每次交互都要联网上传音频，隐私风险大、响应慢、断网即失灵。将 SLM 量化到 INT4 并部署在门锁主控芯片上，实现本地语义理解。

具体案例：某智能家居团队把 1.3B 参数的指令理解模型量化后塞进 2MB 内存的 MCU。用户说“今天有我的快递吗”，门锁本地识别意图，结果通过低功耗蓝牙推送到手机，端到端延迟小于 800ms。

工厂设备预测性维护

阶段：模型裁剪与推理引擎选型

解决的问题：传感器采集的海量振动、温度数据全传云端，带宽成本高且存在断网风险。用 SLM 在边缘盒子本地分析频谱，直接输出异常判断。

具体案例：某制造企业用剪枝加蒸馏后的 0.7B 模型跑在 MNN 引擎上，实时分析 8 路传感器特征。异常检测准确率比传统阈值法提升 23%，误报率下降一半。

太阳能供电的农田物联网问答

阶段：功耗优化

解决的问题：田间节点靠太阳能板加电池供电，每个节点的功耗预算是常规方案的十分之一，必须把模型功耗压到瓦级以下。

具体案例：某农业科技公司用 INT8 量化加 DVFS 调频加空闲休眠，让 0.5B 模型在 10W 太阳能节点上运行，回答作物病虫害问题，模型每季度通过 OTA 更新一次，整机功耗从 6W 降到 1.2W。

Python 演示

python68 行
import numpy as np  def make_mlp(dims):    # 随机初始化一个带 ReLU 隐藏层的 MLP    np.random.seed(42)    params = []    for i in range(len(dims) - 1):        w = np.random.randn(dims[i], dims[i + 1]).astype(np.float32)        b = np.zeros(dims[i + 1], dtype=np.float32)        params.append((w, b))    return params  def inference(params, x):    h = x    for w, b in params[:-1]:        h = np.maximum(0, h @ w + b)   # ReLU    w, b = params[-1]    return h @ w + b  def quantize_int8(params):    # 对称 INT8 量化：求 scale，取整，再回乘近似    quantized = []    for w, b in params:        scale = float(np.max(np.abs(w))) / 127.0        wq = np.clip(np.round(w / scale), -127, 127) * scale        quantized.append((wq.astype(np.float32), b))    return quantized  def prune_weights(params, ratio):    # 按绝对值阈值剪枝：低于阈值的权重清零    pruned = []    for w, b in params:        wp = np.abs(w)        threshold = np.percentile(wp, ratio * 100)        wcopy = w.copy()        wcopy[wp < threshold] = 0.0        pruned.append((wcopy, b))    return pruned  def num_params(params):    return sum(w.size for w, _ in params)  def main():    x = np.random.randn(64, 16).astype(np.float32)    mlp = make_mlp([16, 32, 32, 8])    y_ref = inference(mlp, x)    y_q = inference(quantize_int8(mlp), x)    y_p = inference(prune_weights(mlp, 0.4), x)    mse_q = float(np.mean((y_ref - y_q) ** 2))    mse_p = float(np.mean((y_ref - y_p) ** 2))    fp32_bytes = num_params(mlp) * 4    int8_bytes = fp32_bytes // 4    sparsity = np.mean([np.mean(w == 0) for w, _ in prune_weights(mlp, 0.4)])    print("FP32 params bytes:", fp32_bytes)    print("INT8 params bytes:", int8_bytes)    print("INT8 MSE:", mse_q)    print("prune sparsity:", round(sparsity, 3))    print("prune MSE:", mse_p)  if __name__ == "__main__":    main()
目的：用 numpy 实现一个极简 MLP，对比 FP32、INT8 量化和 40% 剪枝三种方案的参数体积与输出误差，直观演示量化与剪枝的“压缩换精度”权衡。
  1. params.append((w, b))把每一层的权重和偏置打包存放，方便后续统一处理。
  2. h = np.maximum(0, h @ w + b)线性变换加 ReLU 激活，构成隐藏层的前向计算。
  3. scale = float(np.max(np.abs(w))) / 127.0用权重绝对值的最大值确定对称量化比例尺。
  4. wq = np.clip(np.round(w / scale), -127, 127) * scale除以 scale、四舍五入、截断到 [-127,127]，再回乘近似原值。
  5. threshold = np.percentile(wp, ratio * 100)取权重绝对值分布的百分位作为剪枝阈值。
  6. wcopy[wp < threshold] = 0.0把绝对值低于阈值的权重直接清零，形成稀疏网络。
  7. mse_q = float(np.mean((y_ref - y_q) ** 2))用均方误差量化量化前后输出的偏差，验证精度损失。

常见误区

误区量化不就是给模型打个压缩包吗？部署时解压回来，权重和原来一模一样，只是传输时省点流量。

正解量化和 ZIP 压缩完全不同。ZIP 压缩是无损的，解压后逐字节还原；量化把 FP32 权重换算成 INT8/INT4 整数，是近似舍入，信息永久丢失，部署时直接拿低比特数计算。它的“无损”是指精度损失可接受（通常 1%~2%），而不是数值无损。打个比方：真空压缩羽绒服，压完体积小，但羽绒被压实了，回不到最初的蓬松状态。

为何常见：“压缩”一词在日常生活中默认是无损压缩，加上“量化”听起来像“把数据变小”，人们容易混淆有损与无损操作。

误区反正要剪枝，那剪得越多越好，参数少了内存省了，推理速度自然也就上去了。

正解非结构化剪枝产生的是零散稀疏点，通用 CPU/GPU 不做专门优化时，稀疏矩阵运算要逐个查表跳过零元素，额外开销反而可能大于直接计算。只有结构化剪枝（删除整行整列）才能让硬件真正跳过一整块计算。就像整理房间：扔掉零碎小物件，收纳效率提升有限；把整组不用的柜子搬走，空间才真正释放出来。

为何常见：直觉上“参数少了自然更快”，忽略了硬件对规整形状的依赖，也忽略了稀疏矩阵带来的寻址开销。

误区把 FLOPS 算清楚了，推理功耗就出来了。模型越小、计算量越少，就一定越省电。

正解端侧推理功耗 = 计算功耗 + 内存访问功耗 + 静态功耗 + 无线传输功耗。访问一次外部存储器的能耗可能比一次浮点运算高两个数量级；很多场景下 WiFi 或 4G 传数据比算模型还耗电。所以量化不仅省内存，还省“搬运权重”的能量，而功耗优化也要同时盯紧内存拷贝和通信模块。

为何常见：大模型时代大家习惯用算力（FLOPS）衡量一切，忽视了在真实芯片上“数据搬运”往往才是能耗大头。

误区模型已经在设备上跑起来了，指标也达标了，部署工作就算完成了，后面不用再管。

正解端侧模型上线后会遇到输入分布漂移、设备碎片化、固件升级等新问题。需要建立监控机制：定期收集匿名推理日志、和云端大模型对比输出、跑精度回归，再通过 OTA 灰度发布更新模型。部署不是终点，而是设备端 AI 生命周期的起点。

为何常见：实验室验证和线上环境存在天然 gap，加上端侧问题难以复现，工程师容易产生“能跑就等于没问题”的错觉。

面试题

Q1. 一个 7B 参数的模型以 FP32 存储，约占多少内存？

单选题 · easy

  • A.大约 3.5 GB
  • B.大约 28 GB← 正确答案
  • C.大约 7 GB
  • D.大约 14 GB

答案：B。根据公式 M = N × b ÷ 8，7×10⁹ × 32 ÷ 8 ≈ 28GB。选项 A、C、D 分别是 INT4、INT8 和 16 位下的粗略近似值，不是 FP32 的结果。

Q2. 对称 INT8 量化中，把浮点权重换算到整数刻度的核心步骤是（ ）

单选题 · easy

  • A.用最大值算出缩放比例尺且权重取整后回乘近似← 正确答案
  • B.把所有浮点权重直接替换成随机整数
  • C.把模型参数复制一倍以提升计算精度
  • D.把输入和输出顺序颠倒后重新训练

答案：A。对称量化用最大绝对值求 scale，权重除以 scale 后四舍五入取整，推理前再回乘 scale 还原近似值。B 是噪声，C 不提升精度，D 是乱操作。

Q3. 结构化剪枝相对非结构化剪枝的主要优势是（ ）

单选题 · mid

  • A.保持规整结构便于硬件直接加速← 正确答案
  • B.精度损失一定小于非结构化
  • C.不需要任何微调或重训练
  • D.可以直接减少训练数据量

答案：A。结构化剪枝删除整行整列，权重形状规整，GPU/NPU 无需稀疏库就能跳过计算；非结构化剪枝虽然稀疏度更高，但通用硬件处理不规则稀疏矩阵反而更慢。

Q4. 下列属于端侧推理引擎的是（ ）

单选题 · mid

  • A.TFLite 端侧推理框架← 正确答案
  • B.CUDA 显卡运行库
  • C.Hadoop 分布式平台
  • D.PyTorch 训练画板

答案：A。TFLite 是谷歌专为手机和 MCU 设计的端侧推理引擎。CUDA 是显卡编程库，Hadoop 是大数据平台，PyTorch 侧重训练而非端侧轻量推理。

Q5. KV 缓存在流式生成中的作用是（ ）

单选题 · mid

  • A.缓存历史键值避免重复计算← 正确答案
  • B.压缩模型权重降低内存占用
  • C.保存训练数据防止模型遗忘
  • D.加快权重量化的过程

答案：A。生成新 token 时注意力计算要用到前面所有 token 的 Key/Value。缓存后只需计算新 token 的键值，否则复杂度会随序列长度平方增长。KV 缓存和权重压缩、训练数据无关。

Q6. CMOS 芯片动态功耗公式正确的是（ ）

单选题 · extreme

  • A.P = α·C·V²·f← 正确答案
  • B.P = α·C·V·f²
  • C.P = C·V²·f²
  • D.P = α·C·V³·f

答案：A。动态功耗与电压平方成正比、与频率一次方成正比，还包含活动因子 α 和负载电容 C。电压在平方项上，所以 DVFS 降电压比单纯降频省电得多。

Q7. 下列属于模型压缩技术的有（ ）

单选题 · mid

  • A.权重量化压缩← 正确答案
  • B.结构化剪枝← 正确答案
  • C.知识蒸馏← 正确答案
  • D.数据增强清洗

答案：ABC。量化降精度、剪枝删冗余、蒸馏学小模型，是端侧部署三大压缩流派；数据增强属于数据侧手段，并不改变模型大小。

Q8. 端到端部署验证流程包含（ ）

单选题 · mid

  • A.模型格式转换← 正确答案
  • B.精度回归验证← 正确答案
  • C.性能基准测试← 正确答案
  • D.用户界面美化

答案：ABC。转换解决“能不能跑”，精度验证解决“变了多少”，性能基准解决“跑多快”。UI 美化属于产品层，不属于模型部署管线。

Q9. 关于 PTQ 与 QAT，下列说法正确的是（ ）

单选题 · hard

  • A.QAT 在训练中模拟量化误差精度更好← 正确答案
  • B.PTQ 必须重新训练模型才能使用
  • C.QAT 不需要任何校准数据
  • D.PTQ 精度一般优于 QAT

答案：A。QAT（量化感知训练）在训练或微调时把“假量化”注入前向计算，让权重适应取整误差，精度恢复更好；PTQ（训练后量化）无需重训，只用校准数据统计范围，通常精度略逊。

Q10. 下列可降低端侧推理功耗的措施有（ ）

单选题 · hard

  • A.动态调频调压 DVFS← 正确答案
  • B.KV 缓存命中复用← 正确答案
  • C.空闲时进入休眠状态← 正确答案
  • D.全量重算每一个 token

答案：ABC。DVFS 降低电压频率、KV 缓存减少重复计算、休眠省掉静态功耗，三者都显著省电；D 恰恰相反，会引入大量重复的注意力计算，功耗不降反升。