.pt vs .onnx vs .rknn

理解 PyTorch、ONNX、RKNN 三种格式的本质差异——从 pickle 到 protobuf 到 NPU 指令。

---

1. 写在前面

本文是神经网络各层详解的姊妹篇——那篇文章解释了 Conv、Pool、FC、BN 等各层做了什么，本文聚焦这些层的权重和结构以什么格式存储、如何跨框架流转、最终怎么在 NPU 上执行。

我们沿用同一个例子：

输入: 28×28 灰度图
结构: Conv(1→8通道, 3×3核) → ReLU → MaxPool(2×2) → FC(→10类)
输出: 数字 0-9 的识别结果

---

2. 三种格式一句话概括

格式	本质	类比
.pt / .pth	Python pickle + 浮点二进制	"字典 + 一堆 float 数组，结构在代码里"
.onnx	protobuf 计算图 + 权重	"一张蓝图：算子、连接、超参全写着"
.rknn	NPU 指令 + 量化权重	"编译好的二进制，只能跑不能读"

---

3. .pt 文件：Python 的序列化

3.1 文件结构（新版 PyTorch，zip 容器）

model.pt (ZIP)
├── archive/
│   ├── data.pkl     ← pickle: 对象结构描述
│   ├── data/0       ← conv.weight: 72 × 4 = 288 字节
│   ├── data/1       ← conv.bias:   8 × 4 = 32  字节
│   ├── data/2       ← fc.weight:   13520 × 4 = 54080 字节
│   └── data/3       ← fc.bias:     10 × 4 = 40 字节
└── version

3.2 Pickle 是什么

Pickle 是一个栈式虚拟机字节码，不是文本格式：

指令              栈（底→顶）
─────────────────────────────────
EMPTY_DICT       [ {} ]
MARK             [ {}, (mark) ]
'conv.weight'    [ {}, (mark), 'conv.weight' ]
<Tensor ref→0>   [ ..., Tensor→data/0 ]
'conv.bias'      [ ..., 'conv.bias', Tensor→data/1 ]
SETITEMS         [ {'conv.weight':Tensor, 'conv.bias':Tensor} ]
STOP             → 返回 dict

3.3 .pt 的能力边界

✅ 权重数值、张量形状
❌ stride / padding —— 不在文件里
❌ 后面是 ReLU 还是 Sigmoid —— 不在文件里
❌ 网络结构 —— 隐式在 Python 类代码里

本质：.pt 是一组数字 + 隐式公式。 没有 Python 源码，无法重建网络。

---

4. .onnx 文件：显式的计算蓝图

4.1 文件结构（protobuf 二进制）

ModelProto {ir_version: 8graph: GraphProto {node[0] { op_type: "Conv"input:  ["input", "conv.weight", "conv.bias"]output: ["conv_out"]attribute: { kernel_shape: [3,3]  strides: [1,1]  pads: [0,0,0,0] } }node[1] { op_type: "Relu"    input:"conv_out"     output:"relu_out" }node[2] { op_type: "MaxPool" input:"relu_out"     output:"pool_out"kernel_shape:[2,2]  strides:[2,2] }node[3] { op_type: "Gemm"    input:"pool_out_flat","fc.weight","fc.bias"output:"output" }initializer { name: "conv.weight"  dims: [8,1,3,3]  raw_data: <288 字节> }initializer { name: "fc.weight"    dims: [10,1352]  raw_data: <54080 字节> }}
}

4.2 .pt vs .onnx

	.pt	.onnx
格式	pickle + zip	protobuf
包含权重	✅	✅
包含结构	❌（在代码里）	✅（显式计算图）
stride/padding	❌	✅ attribute
激活函数	❌	✅ 独立节点
跨框架	❌	✅

本质：.onnx 是一组数字 + 显式公式。 任何 ONNX 运行时都能执行。

---

5. .rknn 文件：编译后的 NPU 二进制

5.1 ONNX → RKNN

ONNX 图解析├── 算子融合: Conv+BN+ReLU → 一个操作├── 量化:      float32 → int8, 每个 tensor 附 scale + zero_point├── 内存规划:  输入 784B → conv 5408B → pool 1352B → fc 10B└── 生成 NPU 指令序列 → .rknn (不可读微码 + int8 权重)

5.2 NPU vs GPU

	GPU (OpenCL/CUDA)	NPU (RK3576)
算力	~50-100 GFLOPS	6 TOPS (int8)
功耗	几瓦	< 1W
计算方式	im2col + GEMM	专用 MAC 阵列
精度	FP32/FP16	int8/int16
适用	图形渲染	推理专用

本质：.rknn 是编译产物，类似 C 编译出的 ELF。

---

6. 全流程总结

 ┌─────────┐      ┌──────────┐      ┌─────────┐      ┌──────────────┐│  .pt    │ ───→ │  .onnx   │ ───→ │ .rknn   │ ───→ │  RK3576 NPU  ││ pickle  │      │ protobuf │      │ NPU 指令 │      │  6 TOPS      │└─────────┘      └──────────┘      └─────────┘      └──────────────┘torch.save()     torch.             RKNN-            rknn_run()onnx.export()      Toolkit2.build()

7. 实操流程

# PC 端 (x86, conda rknn_toolkit2)
python -c "
import torch
from rknn.api import RKNNmodel = YourModel()
torch.onnx.export(model, dummy_input, 'model.onnx', opset_version=12)rknn = RKNN()
rknn.config(target_platform='rk3576', quantized_dtype='asymmetric_quantized-u8')
rknn.load_onnx('model.onnx')
rknn.build(do_quantization=True)
rknn.export_rknn('model.rknn')
"# RK3576 板端
python -c "
from rknnlite.api import RKNNLiterknn = RKNNLite()
rknn.load_rknn('model.rknn')
rknn.init_runtime(core_mask=0b11)while True:obs = get_observation()action = rknn.inference([obs])send_command(action)
"

---

附录：训练是怎么学的

A. 什么是"参数"

参数 = 训练中被修改的、存在 .pt 里的数值。

层	是参数	不是参数
Conv	weight, bias	stride, padding（超参，固定）
BN	γ, β	μ, σ²（训练累积的统计量）
ReLU	—	输出值（每次前向现场算）
FC	weight, bias	—

B. CrossEntropy：衡量"猜得有多错"

网络输出: [0.1, 0.0, 0.1, 7.8, 0.2, 0.3, ...]  → 第 3 位最高，猜 "3"
正确答案: "5"① Softmax 把分数转概率
② 取正确答案(5)的概率: 0.0001
③ L = -log(0.0001) = 9.2概率越小 → loss 越大；概率=1 → loss=0

C. lr（学习率）

控制参数每步更新幅度的小正数（典型 0.001）。

W_new = W - lr × ∂L/∂Wlr 太大: 参数跳过头，震荡发散
lr 太小: 学得太慢

D. 链式法则：如何计算参数对错误的贡献

反向传播 = 从 L 出发，逐层往回算梯度。

前向: x ─→ Conv ─→ BN ─→ ReLU ─→ FC ─→ L反向: ∂L/∂x ← ∂L/∂Conv ← ∂L/∂BN ← ∂L/∂ReLU ← ∂L/∂FC ← ∂L/∂L=1

FC 层（前向 z = a·W + b）：

∂L/∂W = ∂L/∂z × a           ← z 对 W 求导 = a
∂L/∂b = ∂L/∂z × 1
∂L/∂a = ∂L/∂z × W           ← 往前传CrossEntropy + Softmax 组合:∂L/∂z[i] = softmax(z)[i] - (i 是正确答案 ? 1 : 0)

ReLU：前向正 → 梯度原样传；前向负 → 截断为 0。

BN：

∂L/∂γ = Σ ∂L/∂y × x̂
∂L/∂β = Σ ∂L/∂y × 1

Conv：每个滑动窗口对核权重贡献一份，多个窗口覆盖的输入像素收到多份梯度求和。

数值例子

前向 (FC 层):a=[2.0, 3.0],  W₅=[0.4, 0.6],  z₅=2.9softmax(z)₅ = 0.15,  L = 1.90反向:∂L/∂z₅ = 0.15 - 1 = -0.85∂L/∂W₅[0] = -0.85 × 2.0 = -1.70∂L/∂W₅[1] = -0.85 × 3.0 = -2.55∂L/∂b₅ = -0.85∂L/∂a[0] = -0.85 × 0.4 = -0.34    ← 往前传

全部机械化——每个算子有对偶的反向公式，L.backward() 全自动执行。

E. γ 和 β 如何"学习"

γ 和 β 跟 Conv 的 72 个权重没有本质区别——都通过反向传播更新：

前向: y = γ × x̂ + β
反向: ∂L/∂γ = Σ ∂L/∂y × x̂    ∂L/∂β = Σ ∂L/∂y × 1
更新: γ_new = γ - lr × ∂L/∂γ   β_new = β - lr × ∂L/∂β

直观：每个通道自己学到"这个特征应该多大、偏多少才方便下一层用"。γ 大的通道说明该特征对任务更重要。