yolo11n-pose：架构全解

我们的量化交付包只用了这个模型的前 11 层。这一页把完整结构拆开讲清楚：每一层是什么、多出来的 neck 与 Pose 头在做什么、代价怎么分布，以及这些结构和我们后续几轮接口决策的关系。

所有数字均实测自 release/cricket_highlight_release/model/weights/cricket_encoder.pt，输入 640×640、batch 1 · 2026-09-22

总览

24 层，三段式：backbone(0–10) 抽特征 → neck(11–22) 多尺度融合 → Pose 头(23) 出框和关键点。我们只要第一段。

总参数

2,874,462

yolo11n-pose，nc=1（person）

总算力 @640

7.54 G

FLOPs，batch 1

我们用的段

0–10

47.5% 参数 / 41% FLOPs

截断加速

2.3×

cuda bs=1 12.29 → 5.31 ms

特征维度

1536

4 层 × (avg+max)

结构图

虚线是我们的抽头；实线是模型自己的数据流。注意 neck 的四条跨层连接（6→12、4→15、13→18、10→21），它们正是「融合」的实现方式，也是为什么 neck 不能脱离 backbone 单独存在。

窄屏可左右拖动查看。方框里的数字是层号；括号里是该层输出的通道数与空间尺寸（640 输入）。

backbone（0–10）：我们用的那一段

五次 stride-2 下采样把 640 压到 20×20，通道从 3 升到 256。n 档的缩放是 depth 0.50 / width 0.25 / max_channels 1024 —— 所以 yaml 里写 [512] 的那层实际只有 128 通道。

模块	出现在	一句话
Conv	0,1,3,5,7	3×3 stride-2 卷积 + BN + SiLU，每出现一次分辨率减半
C3k2	2,4,6,8	CSP 结构，特征劈两半、一半过 Bottleneck 再合并
SPPF	9	三次串联 5×5 maxpool，廉价地把感受野撑到全图
C2PSA	10	backbone 里唯一的注意力，2 头自注意力 + FFN

每个模块的内部结构、实际参数与量化视角见下面的特殊层与特殊算子。

量化上的好消息：这段里最"非常规"的两个算子 —— SPPF 的串联 maxpool、C2PSA 的 softmax —— 在 QNN 上全部落 NPU，零 CPU 回退（S23 实测 177 个算子全在 NPU）。

neck（11–22）：多出来的第一块

标准 PAFPN，两趟走完：先自顶向下把深层语义送到浅层，再自底向上把细节送回深层。 Upsample 和 Concat 零参数，真正花钱的是 4 个 C3k2 和 2 个下采样 Conv。

方向	路径	产出	参数
自顶向下	10 →Upsample→ 拼 6 → C3k2(13) →Upsample→ 拼 4 → C3k2(16)	P3/8 64ch 80×80 — 小目标	143,392
自底向上	16 →Conv s2→ 拼 13 → C3k2(19)	P4/16 128ch 40×40 — 中目标	123,712
自底向上	19 →Conv s2→ 拼 10 → C3k2(22)	P5/32 256ch 20×20 — 大目标	526,592

neck 的输出（16/19/22）仍然是带空间维度的特征图，这一点很关键：它是所有"要知道东西在哪"的头的输入。我们项目里的 bowling_subject_head 就是在这三张图上做 RoIAlign。

Pose 头（23）：多出来的第二块

在 P3/P4/P5 三个尺度上各挂三条并行分支（解耦头），所有尺度的结果拼成一个张量。

分支	输出通道	作用	参数
cv2	64 = 16×4	框回归，DFL 形式：每条边预测 16 个 bin 的分布，再取期望得到距离	381,888
cv3	1	类别分数。`nc=1`，只有 `person`	48,963
cv4	51 = 17×3	COCO-17 关键点的 (x, y, visible)	284,427

输出形状: (1, 56, 8400) —— 每个 anchor 56 维 = 4 框 + 1 类 + 51 关键点
8400: 80²+40²+20² = 6400+1600+400，三个尺度的 anchor 总数
还带什么: DFL 解码、anchor/stride 网格生成，推理时外加 NMS

反直觉的一点：Pose 头只有 1 层，却吃掉 37% 的算力（2.83 GFLOPs）—— 因为那三条分支要在 80×80 的高分辨率图上跑满通道。参数占比（24.9%）严重低估了它的真实成本。

特殊层与特殊算子

YOLO11 里真正需要解释的结构就这几个。每个都附上量化视角 —— 它在定点后端上是便宜还是贵、我们实测到什么。

Conv + SiLU —— 基础单元

卷积 + BatchNorm + SiLU。SiLU(x) = x · sigmoid(x)，比 ReLU 平滑、负半轴不完全截断，但代价是它在计算图里是 Sigmoid + Mul 两个算子，不是一个激活函数。

量化视角：BN 在导出时折进卷积权重（定点后端的前提）。所有 block 的动态范围其实由 SiLU 的 Mul 输出决定 —— 我们查编码时看的就是这些 */act/Mul_output_0 张量。

C3k2 —— 主干的重复单元（layer 2/4/6/8）

CSP 思路：1×1 卷积把特征劈两半，一半走 Bottleneck、一半直连，末尾 concat 再 1×1 融合。好处是梯度路径短、重复特征少，参数比堆卷积省。

n 档里两种内部结构并存 —— 这点容易看漏：

层	内部	深度
layer 2 / 4	`C3k=False` → 普通 Bottleneck	1 个，带 shortcut
layer 6 / 8	`C3k=True` → C3k 块	C3k 里再套 2 个 Bottleneck

所以越深的 C3k2 越"厚"，这也是 layer 8 有 346k 参数、 layer 4 只有 26k 的原因。

SPPF —— 廉价的全图感受野（layer 9）

一个 5×5 stride=1 的 maxpool 串联跑三次，把四份结果 concat：串两次等价于 9×9、串三次等价于 13×13。相比并联三个不同核的池化，串联把计算量压到几乎不变，这就是名字里那个 F（Fast）。参数只有两个 1×1 卷积（256→128 和 512→256）。

量化视角：maxpool 只挑值、不产生新数值，量化上完全无害。串联 maxpool 曾是我们担心会回退 CPU 的算子之一 —— 实测全落 NPU。

C2PSA —— backbone 里唯一的注意力（layer 10）

YOLO11 相对 v8 的主要结构改动。在 20×20 的最深层上做 2 头自注意力 + FFN，给纯卷积的 backbone 补一层全局上下文。实际参数：

num_heads: 2（head_dim 64、key_dim 32、scale 0.1768）
qkv: 1×1 卷积 128 → 256，一次算出 Q/K/V
pe: 3×3 深度可分卷积（groups=128）—— 位置编码是卷出来的，不是加上去的
ffn: 1×1 128 → 256 → 128，中间 SiLU

量化视角：注意力里的 QK^T 是全图动态范围最大的张量之一 （实测 −75.7 ~ +117.2，跨度 193）。softmax 输出则被钉在 [−1, 1]。这两个算子当初都被列为"可能回退 CPU"，实测全落 NPU。

Upsample + Concat —— neck 的黏合剂（零参数）

最近邻上采样 + 通道维拼接，不含任何权重，却是 PAFPN "把深层语义和浅层细节混起来"的全部机制。计算上是纯访存。

量化视角 —— 这是我们栽过跟头的地方： 定点后端会让 concat 的输出与各路输入共用一个编码。如果各输入幅度悬殊，幅度大的那一路会被整块截断（我们试过在图内 concat 8 路池化，幅度差 12.8×，直接掉 ρ 0.027）。 neck 的 concat 拼的是幅度相近的卷积激活（≤1.83×），所以安全。 判据：输入幅度比超过约 3× 就要查编码。

DFL —— 把框回归变成分类（Pose 头内）

Distribution Focal Loss 的推理侧实现。每条边不直接回归一个距离，而是预测 16 个 bin 上的概率分布，再取期望得到距离：

距离 = Σ softmax(logits[0..15])ᵢ × i      # i = 0,1,2,…,15

图里它是一个权重固定为 0,1,2,…,15 的 1×1 卷积（实测确认），所以"求期望"这步就是一次卷积。好处是模型能表达"边界在这附近但不确定"，比单点回归稳。这也是 cv2 分支输出 64 通道的原因：4 条边 × 16 个 bin。

量化视角 —— C 臂锁 a16 的硬理由： DFL 解码之后的张量是像素坐标，实测跨度达 765（−40.8 ~ +724.4）。 per-tensor 量化下每档分辨率：int16 = 0.012 px，int8 = 3.0 px。换句话说 a8 下光是最后这一步取整就会让框抖动 3 个像素，而我们在 a16 下实测的整条链路误差才 1.71 px。

量化视角汇总：谁的动态范围大

实测自 C 臂（backbone + neck + Pose 头）的 w8a16 QDQ 图。「每档」= 跨度 ÷ 量化档位数，直接反映该张量能分辨多细。

张量	实测范围	跨度	int16 每档	int8 每档
DFL 解码后的框（像素坐标）	−40.8 ~ +724.4	765	0.012 px	3.0 px
注意力 QK^T（C2PSA）	−75.7 ~ +117.2	193	0.003	0.76
注意力 ×V 之后	−9.3 ~ +8.7	18.0	0.0003	0.071
SPPF maxpool 输出	−7.4 ~ +10.6	18.0	0.0003	0.071
注意力 softmax	−1.0 ~ +1.0	2.0	0.00003	0.008
类别分数 sigmoid	0.0 ~ +1.0	1.0	0.00002	0.004

怎么用这张表：跨度大的张量是 a8 的第一批受害者。 backbone 段当初实测 a8 超线（Δ_irr −0.0164 vs 建议线 −0.005），而 C 臂还多了 DFL 那个跨度 765 的框张量 —— 要试 a8，得先看这张表里排在最前面的几个。

代价分布

这张图解释了为什么截断能拿到 2.3× 而不是 1.9×：省掉的那一半，算力占比比参数占比更大。

backbone 0–10（我们用的） neck 11–22 Pose 头 23

参数2,874,462

FLOPs @6407.54 G

看数据表

段	参数	占比	GFLOPs	占比

逐层表

蓝色高亮行是我们抽特征的四层。from 列里出现列表的就是跨层连接 —— 这些层无法脱离前面的层单独存在。

#	模块	from	输出	stride	参数	GFLOPs

我们怎么用它

打分头和门控头回答的是"这一帧整体像不像一个好动作"——全局语义判断，不需要知道人在哪里。所以我们在层 4/6/8/10 抽特征、池化成 1536 维，neck 和 Pose 头算完就扔。

1536 维是怎么拼的

位置	来源	特征图	avg	max
0–255	层 4（P3）	128×80×80	128	128
256–511	层 6（P4）	128×40×40	128	128
512–1023	层 8（P5）	256×20×20	256	256
1024–1535	层 10（C2PSA）	256×20×20	256	256

顺序是按层交错的 [avg4, max4, avg6, max6, avg8, max8, avg10, max10]，不是按 pool 分组。写成分组顺序不报错，只会静默输出约 0 分。

为什么要写成独立 module

原来用 forward hook 取中间层，但 hook 不进 traced graph —— 导出 ONNX 时图会止于 Pose 头，抽头根本不存在。任何量化/端侧部署都必须从一个显式的单路径 module 开始，这就是 PoseTrunk 的由来。截断后数值逐位一致（max|Δ| = 0.0）。

池化在图内还是图外

默认 pool=True：图内池化，每帧只搬 1536 个数。 pool=False 导出 4 张原始特征图（约 123 万个数，800× 的搬运量），给将来需要定位的头留路 —— 但端上 DMA 代价还没实测。

与量化交付的关系

这段结构上的取舍，直接决定了交付包三个版本的接口长相。

8 路输出 vs 图内 concat v1v2v3

HTP 的激活是 per-tensor 量化，而这 8 个 block 的幅度差十几倍（avg 块 ≲1，max 块到 ~7）。

直接在图内 concat（试过）：量化器给 concat 分配的共享编码是 [-0.27, 1.64]， 所有 max 分支被截断，refit ρ 掉 0.027 —— 特征层仿真说"a16 下等价"，被真量化器推翻。
concat 前逐通道缩放（v2）：把 1536 个通道拉到相近幅度再拼，逐 block 误差与 8 路完全相同（Δρ −0.0013）。
回到 8 路各自量化（v3，当前交付）：每路自带编码，没有共享 range 的问题。

8 路方案下最隐蔽的坑：AI Hub 编译后，8 个输出被重命名为 output_0 … output_7，名字全丢、只能按位置对应。映射已在 S23 上实测验证（端上 vs 本地 QDQ 特征相对 L2 0.00463，映射错了这个数会爆掉）。

任务头只输出 logit v3

头的 ONNX 去掉了 Sigmoid 节点，sigmoid 交给算法 pipeline。动机是 sigmoid 饱和会压平差异（14% 样本 float32 下恰好 ==1.0，反推不回去）；代价是产品阈值是概率，拿 logit 直接比不报错、只是全错。哪些环节能留在 logit 空间，是实测出来的：

环节	能否留在 logit 空间	依据
门控：中值滤波 → 迟滞 → 阈值	✅ 可以，逐位等价阈值 ±0.4055	中值与迟滞只依赖大小关系、sigmoid 单调；2 万点随机检验 `valid` 完全一致
raw 的滑动平均（显示/排序）	❌ 必须先 sigmoid	mean(sigmoid) ≠ sigmoid(mean)，实测最大差 0.39
`soft` 模式 raw × gate	❌ 必须先 sigmoid	乘法在 logit 空间没有对应

padding 维持 114 v3

letterbox 居中填 114，与原版 ultralytics/yolo 约定一致。改成 0 的代价实测是整个量化误差的 5.2 倍（raw mean|Δ| 0.05975 vs 0.01143，100 张里 19 张 [email protected] 判定翻转）—— 因为 backbone 在 114 上预训练、头在 114 的特征分布上拟合 mu/sd、校准集也全是 114。 16:9 广播素材约 44% 画面是填充，最受影响。

需要完整模型的场景，以及待探讨

这两条链路绕不开 neck + Pose 头

bowling_subject_head：在 neck 的 16/19/22 上 RoIAlign，框来自 Pose 头。连 maps 变体都不够 —— 它要的不只是特征图，还要检测结果。
面部可见性微调：需要 COCO-17 关键点，也就是 cv4 那条分支。

如果要把检测头也量化

难点不在 Conv。DFL 解码、anchor 网格、NMS 都不是标准卷积算子，落 NPU 的情况要单独验证；backbone 那段已验证零回退，不能直接外推到头上。

仍未解决

SM8735 真机延迟（农场无此设备，S23 只是同架构代理）
量化 I/O：中端档编译要求输入非浮点；改 uint8 还能把输入 DMA 砍到 1/4
maps 变体的 DMA 代价未实测（约 800× 数据量）

值得一试的方向

产品 pipeline 的门控链改成 logit 空间（已证等价，省两次 sigmoid）
bowling_moment_head 换到量化 backbone 的特征源（它吃的正是这 1536 维）
C2PSA 那层的注意力对 int8 是否更敏感 —— 目前只在 a16 下验证过

这一轮在验什么

以现交付的 backbone 段为基线，在同一台端侧设备（Samsung Galaxy S23 / SM8550 / hexagon v73）上把切点往后推两级，量三件事：延迟、算子落位、每帧要搬多少数据。三个臂用同一份校准集、同样 W8A16、同样编译 runtime，唯一变量是图切到哪里。

延迟与算子落位

每个臂都编译两遍：默认（I/O 为 fp32）与 --quantize_io（I/O 也量化）。后者顺带回答了挂了很久的「量化 I/O」待办。

存储与传输

按 int16 口径比较每帧的输出搬运量。注意输入侧：640×640×3 的输入张量本身就有 1,228,800 个值， fp32 下 4.92 MB/帧 —— 对 backbone 臂来说，输入搬运量是输出的 800 倍，真正的瓶颈在入口不在出口。

每帧搬运量 @uint16线性刻度

A 臂那条几乎看不见 —— 这就是真实量级：1536 个值对上 70 万个。输入行是三个臂共同的入口成本。

搬这些数据要多久

AI Hub 只给推理时间，不单列 DMA。下表按 字节 ÷ 有效带宽 估算，列出几档有效带宽 —— SM8550 的 LPDDR5X 标称峰值约 67 GB/s，单个客户端实际能吃到的通常是峰值的三到五成，所以 20 GB/s 一档最接近现实，5 GB/s 是悲观下界。

为什么是估计而不是实测。用「fp32 I/O → uint16 I/O」的实测差反推有效带宽，三个臂给出的答案差了 5 倍：B 臂省 3.89 MB、延迟降 0.437 ms（反推 8.9 GB/s）； C 臂省 3.40 MB 却只降 0.072 ms（反推 47 GB/s）；A 臂省 2.46 MB 反而慢了 0.156 ms。这说明传输与计算是部分重叠的，而且 qio 同时改变了边界上的换算算子 —— delta 里混着两件事，读不出干净的带宽。所以上表是模型估算，真值要靠端侧打点。

量化误差：切得越深，累积越多

同一批真实图上，QDQ 与 FP32 的相对 L2。越靠后的输出，误差越大 —— 这是本轮的一个关键观察。

Pose 头：数值很稳，抖的是 anchor 选择

59 张有检测的图上（FP32 conf≥0.25）：

口径	量化 vs FP32	读法
top-1 置信度 \|Δ\|	0.0043（最大 0.0136）	判"有没有人"完全一致：59/59
同一 anchor 上框坐标最大 \|Δ\|	1.71 px（最大 4.79）	640×640 画布 —— 量化本身很温和
同一 anchor 上关键点平均位移	1.35 px（最大 2.70）	同上
argmax anchor 翻转	24/59（41%）	相邻 anchor 置信度接近时的选择抖动
各自 top-1 框的 IoU	均值 0.902，92% > 0.9	翻转多数无害，但有个别 IoU=0（选到了另一个人）

怎么读这组数：取 argmax 是没有 NMS 的粗糙代理，真实管线里 NMS 会把相邻 anchor 聚成一个框， 41% 的翻转绝大部分会被吸收。但"两个人置信度接近时选谁"这件事量化确实会改 —— bowling_subject_head 恰恰在意选中的是哪个人，这条要单独验。

一张图两个消费口：再引一组 8 路抽头

B / C 臂只给空间特征或框，现有的打分头与门控头就没得吃了。解法是在同一张图里，把 backbone 的 layer 4/6/8/10 再做一次全局 avg/max 池化引出来 —— 输出多 1536 个值（3 KB），现有两个头不改代码继续用。

怎么写

out = [y[i] for i in self.outputs]          # p3/p4/p5 或 (1,56,8400)
for i in (4, 6, 8, 10):                     # 抽头，顺序仍按 ORDER 按层交错
    out.append(y[i].mean((2, 3)))
    out.append(y[i].amax((2, 3)))

代价：+0.13 ms、+3 KB、+8 个算子（全在 NPU）

臂（均 uint16 I/O）	延迟	Δ	算子落位	输出/帧 @int16
B · backbone + neck	3.992 ms	—	NPU 256 / CPU 0	1.43 MB
B · backbone + neck + 8 路抽头	4.120 ms	+3.2%	NPU 264 / CPU 0	1.44 MB
C · backbone + neck + Pose 头	5.769 ms	—	NPU 376 / CPU 0	0.94 MB
C · backbone + neck + Pose 头 + 8 路抽头	5.900 ms	+2.3%	NPU 384 / CPU 0	0.94 MB

多出来的正好是 8 个池化算子，全部落 NPU、零回退。

关键验证：抽头还是不是原来那个坐标系

量化编码是逐图标定的 —— 同一条 backbone 放进更大的图，池化分支的编码未必还与现交付的 A 臂一致。若不一致，两个头的 mu/sd 就读错了坐标系。 60 张真实图实测：

口径	B+抽头 / C+抽头 vs A 臂	放进量级看
抽头特征相对 L2	0.00112（最大 0.00149）	量化误差本身是 0.027 → 占 4%
交付头读出的 raw \|Δ\|	0.00032（最大 0.00132）	量化本身 0.0114 → 占 3%；比端上实现差异 0.0019 还小
gate \|Δ\|	0.00000（最大 0.00002）	门控判定不受影响
raw 排序相关 ρ	0.999944	排序几乎完全一致

结论：编码确实微调了一点，但远在噪声内 —— mu/sd 不用重拟合，现有两个头直接搬过去即可。 B 与 C 两臂的抽头数值完全一致，说明 backbone 子图在两种切法下量化结果相同，差异只来自「图变大了」本身。

省掉的是「backbone 跑两遍」

现在 bowling_subject_head 那条链路要在 host 上再跑一遍完整模型。合进一张图之后，一次前向同时给出：打分/门控用的 1536 维、人框与关键点（C）或 RoIAlign 用的特征图（B）。

neck 的 Concat 没有重演 v2 的截断

v2 踩过的坑是：真量化器给 concat 选截断式共享 range，把幅度大的输入整块削掉。 neck 有 17 个 concat，这次逐个查了编码。

Concat	各输入跨度	幅度比	结论
/m.12（拼 backbone P4）	9.52 / 10.49	1.10×	输出范围覆盖输入并集，无截断
/m.15（拼 backbone P3）	7.23 / 7.57	1.05×
/m.18（拼 neck 13）	13.26 / 7.23	1.83×
/m.21（拼 backbone P5）	9.52 / 9.52	1.00×
全部 17 个 concat：幅度比中位 1.05×、最大 1.83×
对照：v2 失败的那个	1.10 … 14.08	12.8×	max 分支被整块截断，ρ 掉 0.027

机制说清楚了：截断只在输入幅度严重失配时发生。 neck 的 concat 拼的都是同类卷积激活、幅度相近，所以安全；我们当初那个 concat 拼的是 avg 池化（≲1）和 max 池化（~7–14），差一个数量级，才被共享 range 削掉。

结论

1. Pose 头也能全落 NPU —— 这是本轮最意外的一条

此前担心 DFL 解码、anchor 网格这些非标准卷积算子会回退 CPU。实测 378 个算子全部落 NPU、零回退。注意 NMS 不在图里，仍在 host 侧。

2. 端侧的 neck 比 GPU 上便宜得多

A100 上加 neck 是 +67% 墙钟（访存密集、launch-bound），端侧只有 +26%；加 Pose 头 GPU 上 +124%，端侧 +67%。 GPU 的相对代价不能外推到 NPU —— 这类大图小通道的层，HTP 的访存结构明显更合适。

3. 量化 I/O 的收益取决于搬运量

B 臂（输出 1.43 MB）省 0.44 ms（−10%），峰值内存从 13.76 MB 掉到 2.02 MB； C 臂几乎持平；A 臂输出只有 3 KB，反而慢了 0.16 ms（换算开销大于收益）。 输出越大，量化 I/O 越值。顺带解掉了挂了很久的「量化 I/O」待办：`--quantize_io` 产出的是 uint16 I/O。

4. 切得越深，量化误差累积越多

backbone 池化特征 0.027 → neck 的 P3/P4/P5 是 0.060/0.088/0.107。但任务级看 Pose 头很稳（同 anchor 框差 1.7px）。结论取决于下游怎么用这些张量，不能只看相对 L2。

5. 一张图可以同时喂两类头，代价 3%

B/C 臂再引一组 8 路池化抽头：+0.13 ms、+3 KB、+8 个算子全在 NPU，且抽头与现交付 A 臂的偏差只有量化误差的 3–4% —— 现有两个任务头不用重训、不改代码。

那么切在哪？如果下游只要人框/关键点，C 臂（backbone + neck + Pose 头）是完整方案： 5.84 ms、输出最小（0.94 MB）、零回退，比现在"backbone 量化 + host 上另跑一遍完整模型"划算得多。如果要给 RoIAlign 喂特征图，B 臂（backbone + neck）+ 量化 I/O（3.99 ms / 1.43 MB）是目前的最优点。两者都建议带上 8 路抽头（B 4.12 ms / C 5.90 ms —— 即「+ neck + 抽头」与「+ neck + Pose 头 + 抽头」），这样现有打分与门控头继续可用，一次前向服务两类头。两者都要注意：这些是 S23 代理数，SM8735 仍未实测。