micronet
micronet 是一款专注于深度学习模型压缩与部署的开源工具库，旨在解决复杂神经网络在移动端及嵌入式设备上存储占用大、计算资源消耗高的问题。它通过量化、剪枝和结构优化等技术，帮助开发者将庞大的模型“瘦身”，使其能更高效、稳定地运行在各类硬件平台上。
该工具特别适合从事算法落地工程的开发人员及研究人员使用。micronet 提供了丰富的量化策略，既支持面向训练的高精度量化（QAT）和训练后量化（PTQ），涵盖从二值、三值到低比特等多种精度选择；也提供常规、规整及分组卷积通道剪枝功能。其独特的技术亮点在于灵活的批归一化（BN）融合机制，能够针对不同类型的量化方案自动调整融合策略，有效减少推理延迟。此外，micronet 深度集成了 TensorRT 部署方案，支持动态形状、算子自适应及多种精度校准，打通了从模型压缩到高性能部署的全流程，让算法落地变得更加简单可控。
使用场景
某边缘计算团队正致力于将高精度的人脸识别模型部署到算力受限的安防摄像头端，以满足实时门禁需求。
没有 micronet 时
- 显存溢出无法运行：原始浮点模型体积过大，远超嵌入式设备的存储上限，导致模型根本无法加载。
- 推理延迟过高：在 CPU 上进行全精度计算耗时严重，单帧处理时间超过 500ms，完全无法满足“秒级开门”的体验要求。
- 量化调试极其繁琐：尝试手动实现低比特量化时，缺乏对 BatchNorm 层融合的支持，导致精度大幅下跌且难以定位误差来源。
- 硬件适配困难：面对 TensorRT 部署中动态形状（dynamic_shape）和特殊算子（如 upsample）的兼容性问题，需耗费数周编写底层适配代码。
使用 micronet 后
- 模型体积缩减 75%：利用 micronet 的二值化（BNN）或三值化（TWN）量化技术，将模型压缩至原大小的四分之一，轻松存入设备闪存。
- 推理速度提升 4 倍：通过量化感知训练（QAT）结合 TensorRT 的 INT8 部署，单帧推理耗时降至 120ms 以内，实现流畅实时检测。
- 精度损失可控：借助 micronet 特有的训练中 BN 参数融合机制（将 BN 统计量合并至卷积权重），有效抑制了量化抖动，精度仅下降约 1%。
- 部署流程自动化：直接调用 micronet 的部署模块即可自动处理算子适配与动态形状校准，将原本数周的移植工作缩短至两天完成。
micronet 通过一站式的高阶量化与剪枝方案，成功打通了从复杂算法模型到高效边缘落地的“最后一公里”。
运行环境要求
- 未说明
非必需（支持 CPU 及单卡/多卡 GPU），具体型号和显存大小未说明，需匹配所安装的 PyTorch 和 TensorRT 版本对应的 CUDA 环境
未说明
快速开始
micronet
"目前在深度学习领域分类两个派别，一派为学院派，研究强大、复杂的模型网络和实验方法，为了追求更高的性能；另一派为工程派，旨在将算法更稳定、高效的落地在硬件平台上，效率是其追求的目标。复杂的模型固然具有更好的性能，但是高额的存储空间、计算资源消耗是使其难以有效的应用在各硬件平台上的重要原因。所以，深度神经网络日益增长的规模为深度学习在移动端的部署带来了巨大的挑战，深度学习模型压缩与部署成为了学术界和工业界都重点关注的研究领域之一"
项目简介
micronet, a model compression and deploy lib.
压缩
- 量化：High-Bit(>2b): QAT, PTQ, QAFT; Low-Bit(≤2b)/Ternary and Binary: QAT
- 剪枝：正常、规整和分组卷积结构剪枝
- 针对特征(A)二值量化的BN融合(训练量化后，BN参数 —> conv的偏置b)
- High-Bit量化的BN融合(训练量化中，先融合再量化，融合：BN参数 —> conv的权重w和偏置b)
部署
- TensorRT(fp32/fp16/int8(ptq-calibration)、op-adapt(upsample)、dynamic_shape等)
代码结构
micronet
├── __init__.py
├── base_module
│ ├── __init__.py
│ └── op.py
├── compression
│ ├── README.md
│ ├── __init__.py
│ ├── pruning
│ │ ├── README.md
│ │ ├── __init__.py
│ │ ├── gc_prune.py
│ │ ├── main.py
│ │ ├── models_save
│ │ │ └── models_save.txt
│ │ └── normal_regular_prune.py
│ └── quantization
│ ├── README.md
│ ├── __init__.py
│ ├── wbwtab
│ │ ├── __init__.py
│ │ ├── bn_fuse
│ │ │ ├── bn_fuse.py
│ │ │ ├── bn_fused_model_test.py
│ │ │ └── models_save
│ │ │ └── models_save.txt
│ │ ├── main.py
│ │ ├── models_save
│ │ │ └── models_save.txt
│ │ └── quantize.py
│ └── wqaq
│ ├── __init__.py
│ ├── dorefa
│ │ ├── __init__.py
│ │ ├── main.py
│ │ ├── models_save
│ │ │ └── models_save.txt
│ │ ├── quant_model_test
│ │ │ ├── models_save
│ │ │ │ └── models_save.txt
│ │ │ ├── quant_model_para.py
│ │ │ └── quant_model_test.py
│ │ └……
项目进展
- 2019.12.4, 初次提交
- 12.8, DoReFa特征(A)量化前先进行缩放(* 0.1)，然后再截断，以减小截断误差
- 12.11, 增加项目代码结构图
- 12.12, 完善使用示例
- 12.14, 增加:1、BN融合量化情况(W三值/二值)可选，即训练量化时选择W三/二值，这里则对应选择; 2、BN融合时对卷积核(conv)不带偏置(bias)的处理
- 12.17, 增加模型压缩前后数据对比(示例)
- 12.20, 增加设备可选(cpu、gpu(单卡、多卡))
- 12.27, 补充相关论文
- 12.29, 取消High-Bit量化8-bit以内的限制，即现在可以量化至10-bit、16-bit等
- 2020.2.17, 1、精简W三值/二值量化代码; 2、加速W三值量化训练
- 2.18, 优化针对特征(A)二值的BN融合:去除对BN层gamma参数的限制，即现在此情况下融合时BN可正常训练
- 2.24, 再次优化三/二值量化代码组织结构，增强可移植性，旧版确实不太好移植。目前移植方法：将想要量化的Conv用compression/quantization/wbwtab/models/util_wbwtab.py中的QuantConv2d替换即可，可参照该路径下nin_gc.py中的使用方法
- 3.1, 新增：1、google的High-Bit量化方法; 2、训练中High-Bit量化的BN融合
- 3.2、3.3, 规整量化代码整体结构，目前所有量化方法都可采取类似的移植方式：将想要量化的Conv(或FC，目前dorefa支持，其他方法类似可写)用models/util_wxax.py中的QuantConv2d(或QuantLinear)替换即可，可分别参照该路径下nin_gc.py中的使用方法进行移植（分类、检测、分割等均适用，但需要据实际情况具体调试）
- 3.4, 规整优化wbwtab/bn_fuse中“针对特征(A)二值的BN融合”的相关实现代码，可进行BN融合及融合前后模型对比测试(精度/速度/(大小))
- 3.11, 调整compression/wqaq/iao中的BN层momentum参数(0.1 —> 0.01),削弱batch统计参数占比,一定程度抑制量化带来的抖动。经实验,量化训练更稳定,acc提升1%左右
- 3.13, 更新代码结构图
- 4.6, 修正二值量化训练中W_clip的相关问题(之前由于这个，导致二值量化训练精度上不去，现在已可正常使用)(同时修正无法找到一些模块如models/util_wxax.py的问题)
- 12.14, 1、improve code structure; 2、add deploy-tensorrt(main module, but not running yet)
- 12.18, 1、improve code structure/module reference/module_name; 2、add transfer-use demo
- 12.21, improve pruning-quantization pipeline和代码
- 2021.1.4, add other quant_op
- 1.5, add quant_weight's per-channel和 per-layer selection
- 1.7, fix iao's loss-nan bug. The bug is due to per-channel min/max error
- 1.8, 1、improve quant_para save. Now, only save scale and zero_point; 2、add optional weight_observer(MinMaxObserver or MovingAverageMinMaxObserver)
- 1.11, fix bug in binary_a(1/0) and binary_w preprocessing
- 1.12, add "pip install"
- 1.22, add auto_insert_quant_op(this still needs to be improved)
- 1.27, improve auto_insert_quant_op(now you can easily use quantization, as quant_test_auto)
- 1.28, 1、fix prune-quantization pipeline和代码; 2、improve code structure
- 2.1, improve wbwtab_bn_fuse
- 2.4, 1、add wqaq_bn_fuse; 2、add quant_model_inference_simulation; 3、improve code format
- 4.30, 1、update code_structure img; 2、fix iao's quant_weight_range, quant_contrans and quant_bn_fuse_conv pretrained_model bn_para load bug
- 5.4, add qaft, it's beneficial to improve the quantization accuracy
- 5.6, add ptq, its quantization accuracy is also good
- 5.11, add bn_fuse_calib flag
- 5.14, 1、change ste to clip_ste, it's beneficial to improve the quant_train；2、remove quant_relu和 add quant_leaky_relu
- 5.15, fix bug in quant_model_para post-processing
- 6.7, add quant_add(need use base_module's op) and quant_resnet demo
- 6.9, iao_quant supports multi gpus
- 6.16, fix quant_round() and quant_binary()
- 10.6, format
环境要求
- python >= 3.5
- torch >= 1.1.0
- torchvison >= 0.3.0
- numpy
- onnx == 1.6.0
- tensorrt == 7.0.0.11
安装
pip install micronet -i https://pypi.org/simple
git clone https://github.com/666DZY666/micronet.git
cd micronet
python setup.py install
验证
python -c "import micronet; print(micronet.__version__)"
测试
Install from github
压缩
量化
--refine,可加载预训练浮点模型参数,在其基础上做量化
wbwtab
--W --A, 权重W和特征A量化取值
cd micronet/compression/quantization/wbwtab
- WbAb
python main.py --W 2 --A 2
- WbA32
python main.py --W 2 --A 32
- WtAb
python main.py --W 3 --A 2
- WtA32
python main.py --W 3 --A 32
wqaq
--w_bits --a_bits, 权重W和特征A量化位数
dorefa
cd micronet/compression/quantization/wqaq/dorefa
- W16A16
python main.py --w_bits 16 --a_bits 16
- W8A8
python main.py --w_bits 8 --a_bits 8
- W4A4
python main.py --w_bits 4 --a_bits 4
- 其他bits情况类比
iao
cd micronet/compression/quantization/wqaq/iao
量化位数选择同dorefa
单卡
QAT/PTQ —> QAFT
! 注意，需要在QAT/PTQ之后再做QAFT !
--q_type, 量化类型(0-对称, 1-非对称)
--q_level, 权重量化级别(0-通道级, 1-层级)
--weight_observer, weight_observer选择(0-MinMaxObserver, 1-MovingAverageMinMaxObserver)
--bn_fuse, 量化中bn融合标志
--bn_fuse_calib, 量化中bn融合校准标志
--pretrained_model, 预训练浮点模型
--qaft, qaft标志
--ptq, ptq_observer
--ptq_control, ptq_control
--ptq_batch, ptq的batch数量
--percentile, ptq校准的比例
QAT
- 默认: 对称、(权重)通道级量化, bn不融合, weight_observer-MinMaxObserver, 不加载预训练浮点模型, 进行qat
python main.py --q_type 0 --q_level 0 --weight_observer 0
- 对称、(权重)通道级量化, bn不融合, weight_observer-MovingAverageMinMaxObserver
python main.py --q_type 0 --q_level 0 --weight_observer 1
- 对称、(权重)层级量化, bn不融合
python main.py --q_type 0 --q_level 1
- 非对称、(权重)通道级量化, bn不融合
python main.py --q_type 1 --q_level 0
- 非对称、(权重)层级量化, bn不融合
python main.py --q_type 1 --q_level 1
- 对称、(权重)通道级量化, bn融合
python main.py --q_type 0 --q_level 0 --bn_fuse
- 对称、(权重)层级量化, bn融合
python main.py --q_type 0 --q_level 1 --bn_fuse
- 非对称、(权重)通道级量化, bn融合
python main.py --q_type 1 --q_level 0 --bn_fuse
- 非对称、(权重)层级量化, bn融合
python main.py --q_type 1 --q_level 1 --bn_fuse
- 对称、(权重)通道级量化, bn融合校准
python main.py --q_type 0 --q_level 0 --bn_fuse --bn_fuse_calib
PTQ
需要加载预训练浮点模型,本项目中其可由剪枝中采用正常训练获取
- 对称、(权重)通道级量化, bn融合
python main.py --refine ../../../pruning/models_save/nin_gc.pth --q_level 0 --bn_fuse --pretrained_model --ptq_control --ptq --batch_size 32 --ptq_batch 200 --percentile 0.999999
- 其他情况类比
QAFT
! 注意，需要在QAT/PTQ之后再做QAFT !
QAT —> QAFT
- 对称、(权重)通道级量化, bn融合
python main.py --resume models_save/nin_gc_bn_fused.pth --q_type 0 --q_level 0 --bn_fuse --qaft --lr 0.00001
- 其他情况类比
PTQ —> QAFT
- 对称、(权重)通道级量化, bn融合
python main.py --resume models_save/nin_gc_bn_fused.pth --q_level 0 --bn_fuse --qaft --lr 0.00001 --ptq
- 其他情况类比
剪枝
稀疏训练 —> 剪枝 —> 微调
cd micronet/compression/pruning
稀疏训练
-sr 稀疏标志
--s 稀疏率(需根据dataset、model情况具体调整)
--model_type 模型类型(0-nin, 1-nin_gc)
- nin(正常卷积结构)
python main.py -sr --s 0.0001 --model_type 0
- nin_gc(含分组卷积结构)
python main.py -sr --s 0.001 --model_type 1
剪枝
--percent 剪枝率
--normal_regular 正常、规整剪枝标志及规整剪枝基数(如设置为N,则剪枝后模型每层filter个数即为N的倍数)
--model 稀疏训练后的model路径
--save 剪枝后保存的model路径（路径默认已给出, 可据实际情况更改）
- 正常剪枝(nin)
python normal_regular_prune.py --percent 0.5 --model models_save/nin_sparse.pth --save models_save/nin_prune.pth
- 规整剪枝(nin)
python normal_regular_prune.py --percent 0.5 --normal_regular 8 --model models_save/nin_sparse.pth --save models_save/nin_prune.pth
或
python normal_regular_prune.py --percent 0.5 --normal_regular 16 --model models_save/nin_sparse.pth --save models_save/nin_prune.pth
- 分组卷积结构剪枝(nin_gc)
python gc_prune.py --percent 0.4 --model models_save/nin_gc_sparse.pth
微调
--prune_refine 剪枝后的model路径（在其基础上做微调）
- nin
python main.py --model_type 0 --prune_refine models_save/nin_prune.pth
- nin_gc
需要传入剪枝后得到的新模型的cfg
如
python main.py --model_type 1 --gc_prune_refine 154 162 144 304 320 320 608 584
剪枝 —> 量化（注意剪枝率和量化率平衡）
加载剪枝后的浮点模型再做量化
剪枝 —> 量化（高位）（剪枝率偏大、量化率偏小）
w8a8(dorefa)
cd micronet/compression/quantization/wqaq/dorefa
- nin(正常卷积结构)
python main.py --w_bits 8 --a_bits 8 --model_type 0 --prune_quant ../../../pruning/models_save/nin_finetune.pth
- nin_gc(含分组卷积结构)
python main.py --w_bits 8 --a_bits 8 --model_type 1 --prune_quant ../../../pruning/models_save/nin_gc_retrain.pth
w8a8(iao)
cd micronet/compression/quantization/wqaq/iao
QAT/PTQ —> QAFT
! 注意，需要在QAT/PTQ之后再做QAFT !
QAT
bn不融合
- nin(正常卷积结构)
python main.py --w_bits 8 --a_bits 8 --model_type 0 --prune_quant ../../../pruning/models_save/nin_finetune.pth --lr 0.001
- nin_gc(含分组卷积结构)
python main.py --w_bits 8 --a_bits 8 --model_type 1 --prune_quant ../../../pruning/models_save/nin_gc_retrain.pth --lr 0.001
bn融合
- nin(正常卷积结构)
python main.py --w_bits 8 --a_bits 8 --model_type 0 --prune_quant ../../../pruning/models_save/nin_finetune.pth --bn_fuse --pretrained_model --lr 0.001
- nin_gc(含分组卷积结构)
python main.py --w_bits 8 --a_bits 8 --model_type 1 --prune_quant ../../../pruning/models_save/nin_gc_retrain.pth --bn_fuse --pretrained_model --lr 0.001
PTQ
- nin(正常卷积结构)
python main.py --w_bits 8 --a_bits 8 --model_type 0 --prune_quant ../../../pruning/models_save/nin_finetune.pth --bn_fuse --pretrained_model --ptq_control --ptq --batch_size 32 --ptq_batch 200 --percentile 0.999999
- 其他情况类比
QAFT
! 注意，需要在QAT/PTQ之后再做QAFT !
QAT —> QAFT
bn不融合
- nin(正常卷积结构)
python main.py --w_bits 8 --a_bits 8 --model_type 0 --prune_qaft models_save/nin.pth --qaft --lr 0.00001
- nin_gc(含分组卷积结构)
python main.py --w_bits 8 --a_bits 8 --model_type 1 --prune_qaft models_save/nin_gc.pth --qaft --lr 0.00001
bn融合
- nin(正常卷积结构)
python main.py --w_bits 8 --a_bits 8 --model_type 0 --prune_qaft models_save/nin_bn_fused.pth --bn_fuse --qaft --lr 0.00001
- nin_gc(含分组卷积结构)
python main.py --w_bits 8 --a_bits 8 --model_type 1 --prune_qaft models_save/nin_gc_bn_fused.pth --bn_fuse --qaft --lr 0.00001
PTQ —> QAFT
bn不融合
- nin(正常卷积结构)
python main.py --w_bits 8 --a_bits 8 --model_type 0 --prune_qaft models_save/nin.pth --qaft --lr 0.00001 --ptq
- nin_gc(含分组卷积结构)
python main.py --w_bits 8 --a_bits 8 --model_type 1 --prune_qaft models_save/nin_gc.pth --qaft --lr 0.00001 --ptq
bn融合
- nin(正常卷积结构)
python main.py --w_bits 8 --a_bits 8 --model_type 0 --prune_qaft models_save/nin_bn_fused.pth --bn_fuse --qaft --lr 0.00001 --ptq
- nin_gc(含分组卷积结构)
python main.py --w_bits 8 --a_bits 8 --model_type 1 --prune_qaft models_save/nin_gc_bn_fused.pth --bn_fuse --qaft --lr 0.00001 --ptq
其他可选量化配置类比
剪枝 —> 量化（低位）（剪枝率偏小、量化率偏大）
cd micronet/compression/quantization/wbwtab
wbab
- nin(正常卷积结构)
python main.py --W 2 --A 2 --model_type 0 --prune_quant ../../pruning/models_save/nin_finetune.pth
- nin_gc(含分组卷积结构)
python main.py --W 2 --A 2 --model_type 1 --prune_quant ../../pruning/models_save/nin_gc_retrain.pth
其他取值情况类比
BN融合与量化推理仿真测试
wbwtab
cd micronet/compression/quantization/wbwtab/bn_fuse
bn_fuse(得到quant_model_train和quant_bn_fused_model_inference的结构和参数)
--model_type, 1 - nin_gc(含分组卷积结构); 0 - nin(正常卷积结构)
--prune_quant, 剪枝_量化模型标志
--W, weight量化取值
均需要与量化训练保持一致,可直接用默认
- nin_gc, quant_model, wb
python bn_fuse.py --model_type 1 --W 2
- nin_gc、剪枝量化模型、wb
python bn_fuse.py --model_type 1 --prune_quant --W 2
- nin_gc、量化模型、wt
python bn_fuse.py --model_type 1 --W 3
- nin、量化模型、wb
python bn_fuse.py --model_type 0 --W 2
bn_fused_model_test（对quant_model_train和quant_bn_fused_model_inference进行测试）
python bn_fused_model_test.py
dorefa
cd micronet/compression/quantization/wqaq/dorefa/quant_model_test
quant_model_para（获取quant_model_train和quant_model_inference的结构和参数）
--model_type，1 - nin_gc（含分组卷积结构）；0 - nin（正常卷积结构）
--prune_quant，剪枝_量化模型标志
--w_bits，权重量化位数；--a_bits，激活量化的位数
均需与量化训练保持一致，可直接使用默认值
- nin_gc、量化模型、w8a8
python quant_model_para.py --model_type 1 --w_bits 8 --a_bits 8
- nin_gc、剪枝量化模型、w8a8
python quant_model_para.py --model_type 1 --prune_quant --w_bits 8 --a_bits 8
- nin、量化模型、w8a8
python quant_model_para.py --model_type 0 --w_bits 8 --a_bits 8
quant_model_test（对quant_model_train和quant_model_inference进行测试）
python quant_model_test.py
iao
注意，量化训练时 --bn_fuse 需要设置为 True
cd micronet/compression/quantization/wqaq/iao/bn_fuse
bn_fuse（获取quant_bn_fused_model_train和quant_bn_fused_model_inference的结构和参数）
--model_type，1 - nin_gc（含分组卷积结构）；0 - nin（正常卷积结构）
--prune_quant，剪枝_量化模型标志
--w_bits，权重量化位数；--a_bits，激活量化的位数
--q_type，0 - 对称；1 - 非对称
--q_level，0 - 通道级；1 - 层级
均需与量化训练保持一致，可直接使用默认值
- nin_gc、量化模型、w8a8
python bn_fuse.py --model_type 1 --w_bits 8 --a_bits 8
- nin_gc、剪枝量化模型、w8a8
python bn_fuse.py --model_type 1 --prune_quant --w_bits 8 --a_bits 8
- nin、量化模型、w8a8
python bn_fuse.py --model_type 0 --w_bits 8 --a_bits 8
- nin_gc、量化模型、w8a8、非对称、层级
python bn_fuse.py --model_type 0 --w_bits 8 --a_bits 8 --q_type 1 --q_level 1
bn_fused_model_test（对quant_bn_fused_model_train和quant_bn_fused_model_inference进行测试）
python bn_fused_model_test.py
设备选取
目前支持CPU、GPU（单卡、多卡）
--cpu 使用CPU，--gpu_id 使用并选择GPU
- CPU
python main.py --cpu
- GPU单卡
python main.py --gpu_id 0
或
python main.py --gpu_id 1
- GPU多卡
python main.py --gpu_id 0,1
或
python main.py --gpu_id 0,1,2
默认情况下，使用服务器所有显卡
部署
TensorRT
目前仅提供相关核心模块代码，后续再加入完整可运行demo
相关解读
迁移
量化训练
LeNet示例
quant_test_manual.py
只需将op替换为quant_op，即可对模型进行量化（高比特(>2b)、低比特(≤2b)/三值和二值）。
import torch.nn as nn
import torch.nn.functional as F
# 一些基础op，例如``Add``、``Concat``
from micronet.base_module.op import *
# ``quantize`` 是量化模块，``QuantConv2d``、``QuantLinear``、``QuantMaxPool2d``、``QuantReLU`` 是量化操作
from micronet.compression.quantization.wbwtab.quantize import (
QuantConv2d as quant_conv_wbwtab,
)
from micronet.compression.quantization.wbwtab.quantize import (
ActivationQuantizer as quant_relu_wbwtab,
)
from micronet.compression.quantization.wqaq.dorefa.quantize import (
QuantConv2d as quant_conv_dorefa,
)
from micronet.compression.quantization.wqaq.dorefa.quantize import (
QuantLinear as quant_linear_dorefa,
)
from micronet.compression.quantization.wqaq.iao.quantize import (
QuantConv2d as quant_conv_iao,
)
from micronet.compression.quantization.wqaq.iao.quantize import (
QuantLinear as quant_linear_iao,
)
from micronet.compression.quantization.wqaq.iao.quantize import (
QuantMaxPool2d as quant_max_pool_iao,
)
from micronet.compression.quantization.wqaq.iao.quantize import (
QuantReLU as quant_relu_iao,
)
class LeNet(nn.Module):
def __init__(self):
super(LeNet, self).__init__()
self.conv1 = nn.Conv2d(1, 10, kernel_size=5)
self.conv2 = nn.Conv2d(10, 20, kernel_size=5)
self.fc1 = nn.Linear(320, 50)
self.fc2 = nn.Linear(50, 10)
self.max_pool = nn.MaxPool2d(kernel_size=2)
self.relu = nn.ReLU(inplace=True)
def forward(self, x):
x = self.relu(self.max_pool(self.conv1(x)))
x = self.relu(self.max_pool(self.conv2(x)))
x = x.view(-1, 320)
x = self.relu(self.fc1(x))
x = F.dropout(x, training=self.training)
x = self.fc2(x)
return F.log_softmax(x, dim=1)
class QuantLeNetWbWtAb(nn.Module):
def __init__(self):
super(QuantLeNetWbWtAb, self).__init__()
self.conv1 = quant_conv_wbwtab(1, 10, kernel_size=5)
self.conv2 = quant_conv_wbwtab(10, 20, kernel_size=5)
self.fc1 = nn.Linear(320, 50)
self.fc2 = nn.Linear(50, 10)
self.max_pool = nn.MaxPool2d(kernel_size=2)
self.relu = quant_relu_wbwtab()
def forward(self, x):
x = self.relu(self.max_pool(self.conv1(x)))
x = self.relu(self.max_pool(self.conv2(x)))
x = x.view(-1, 320)
x = self.relu(self.fc1(x))
x = F.dropout(x, training=self.training)
x = self.fc2(x)
return F.log_softmax(x, dim=1)
class QuantLeNetDoReFa(nn.Module):
def __init__(self):
super(QuantLeNetDoReFa, self).__init__()
self.conv1 = quant_conv_dorefa(1, 10, kernel_size=5)
self.conv2 = quant_conv_dorefa(10, 20, kernel_size=5)
self.fc1 = quant_linear_dorefa(320, 50)
self.fc2 = quant_linear_dorefa(50, 10)
self.max_pool = nn.MaxPool2d(kernel_size=2)
self.relu = nn.ReLU(inplace=True)
def forward(self, x):
x = self.relu(self.max_pool(self.conv1(x)))
x = self.relu(self.max_pool(self.conv2(x)))
x = x.view(-1, 320)
x = self.relu(self.fc1(x))
x = F.dropout(x, training=self.training)
x = self.fc2(x)
return F.log_softmax(x, dim=1)
class QuantLeNetIAO(nn.Module):
def __init__(self):
super(QuantLeNetIAO, self).__init__()
self.conv1 = quant_conv_iao(1, 10, kernel_size=5)
self.conv2 = quant_conv_iao(10, 20, kernel_size=5)
self.fc1 = quant_linear_iao(320, 50)
self.fc2 = quant_linear_iao(50, 10)
self.max_pool = quant_max_pool_iao(kernel_size=2)
self.relu = nn.ReLU(inplace=True)
def forward(self, x):
x = self.relu(self.max_pool(self.conv1(x)))
x = self.relu(self.max_pool(self.conv2(x)))
x = x.view(-1, 320)
x = self.relu(self.fc1(x))
x = F.dropout(x, training=self.training)
x = self.fc2(x)
return F.log_softmax(x, dim=1)
lenet = LeNet()
quant_lenet_wbwtab = QuantLeNetWbWtAb()
quant_lenet_dorefa = QuantLeNetDoReFa()
quant_lenet_iao = QuantLeNetIAO()
print("***ori_model***\n", lenet)
print("\n***quant_model_wbwtab***\n", quant_lenet_wbwtab)
print("\n***quant_model_dorefa***\n", quant_lenet_dorefa)
print("\n***quant_model_iao***\n", quant_lenet_iao)
print("\nquant_model is ready")
print("micronet is ready")
quant_test_auto.py
只需使用 micronet.compression.quantization.quantize.prepare(model)，即可对模型进行量化（高比特（>2b）、低比特（≤2b）/三值和二值）。
import torch.nn as nn
import torch.nn.functional as F
# 一些基础操作，如 ``Add``、``Concat``
from micronet.base_module.op import *
import micronet.compression.quantization.wqaq.dorefa.quantize as quant_dorefa
import micronet.compression.quantization.wqaq.iao.quantize as quant_iao
class LeNet(nn.Module):
def __init__(self):
super(LeNet, self).__init__()
self.conv1 = nn.Conv2d(1, 10, kernel_size=5)
self.conv2 = nn.Conv2d(10, 20, kernel_size=5)
self.fc1 = nn.Linear(320, 50)
self.fc2 = nn.Linear(50, 10)
self.max_pool = nn.MaxPool2d(kernel_size=2)
self.relu = nn.ReLU(inplace=True)
def forward(self, x):
x = self.relu(self.max_pool(self.conv1(x)))
x = self.relu(self.max_pool(self.conv2(x)))
x = x.view(-1, 320)
x = self.relu(self.fc1(x))
x = F.dropout(x, training=self.training)
x = self.fc2(x)
return F.log_softmax(x, dim=1)
"""
--w_bits --a_bits，权重W和特征A量化位数
--q_type，量化类型（0-对称，1-非对称）
--q_level，权重量化级别（0-通道级，1-层级）
--weight_observer，weight observer选择（0-MinMaxObserver，1-MovingAverageMinMaxObserver）
--bn_fuse，量化中bn融合标志
--bn_fuse_calib，量化中bn融合校准标志
--pretrained_model，预训练浮点模型
--qaft，qaft标志
--ptq，ptq标志
--percentile，ptq校准的比例
"""
lenet = LeNet()
quant_lenet_dorefa = quant_dorefa.prepare(lenet，inplace=False，a_bits=8，w_bits=8)
quant_lenet_iao = quant_iao.prepare(
lenet，
inplace=False，
a_bits=8，
w_bits=8，
q_type=0，
q_level=0，
weight_observer=0，
bn_fuse=False，
bn_fuse_calib=False，
pretrained_model=False，
qaft=False，
ptq=False，
percentile=0.9999，
)
# 如果ptq == False，进行qat/qaft，需要训练
# 如果ptq == True，进行ptq，不需要训练
# 可以参考 micronet/compression/quantization/wqaq/iao/main.py
print("***ori_model***\n", lenet)
print("\n***quant_model_dorefa***\n", quant_lenet_dorefa)
print("\n***quant_model_iao***\n", quant_lenet_iao)
print("\nquant_model is ready")
print("micronet is ready")
测试
quant_test_manual
python -c "import micronet; micronet.quant_test_manual()"
quant_test_auto
python -c "import micronet; micronet.quant_test_auto()"
当输出“quant_model is ready”时，micronet即已准备就绪。
量化推理
模型压缩数据对比（仅供参考）
以下为cifar10示例，可在更冗余模型、更大数据集上尝试其他组合压缩方式
| 类型 | W(Bits) | A(Bits) | Acc | GFLOPs | Para(M) | Size(MB) | 压缩率 | 损失 |
|---|---|---|---|---|---|---|---|---|
| 原模型(nin) | FP32 | FP32 | 91.01% | 0.15 | 0.67 | 2.68 | *** | *** |
| 采用分组卷积结构(nin_gc) | FP32 | FP32 | 91.04% | 0.15 | 0.58 | 2.32 | 13.43% | -0.03% |
| 剪枝 | FP32 | FP32 | 90.26% | 0.09 | 0.32 | 1.28 | 52.24% | 0.75% |
| 量化 | 1 | FP32 | 90.93% | *** | 0.58 | 0.204 | 92.39% | 0.08% |
| 量化 | 1.5 | FP32 | 91% | *** | 0.58 | 0.272 | 89.85% | 0.01% |
| 量化 | 1 | 1 | 86.23% | *** | 0.58 | 0.204 | 92.39% | 4.78% |
| 量化 | 1.5 | 1 | 86.48% | *** | 0.58 | 0.272 | 89.85% | 4.53% |
| 量化(DoReFa) | 8 | 8 | 91.03% | *** | 0.58 | 0.596 | 77.76% | -0.02% |
| 量化(IAO,全量化,symmetric/per-channel/bn_fuse) | 8 | 8 | 90.99% | *** | 0.58 | 0.596 | 77.76% | 0.02% |
| 分组+剪枝+量化 | 1.5 | 1 | 86.13% | *** | 0.32 | 0.19 | 92.91% | 4.88% |
--train_batch_size 256, 单卡
相关资料
压缩
量化
QAT
二值
BinarizedNeuralNetworks: TrainingNeuralNetworkswithWeightsand ActivationsConstrainedto +1 or−1
XNOR-Net:ImageNetClassificationUsingBinary ConvolutionalNeuralNetworks
三值
High-Bit
- DoReFa-Net: Training Low Bitwidth Convolutional Neural Networks with Low Bitwidth Gradients
- Quantization and Training of Neural Networks for Efficient Integer-Arithmetic-Only Inference
- Quantizing deep convolutional networks for efficient inference: A whitepaper
PTQ
High-Bit
剪枝
- Learning Efficient Convolutional Networks through Network Slimming
- RETHINKING THE VALUE OF NETWORK PRUNING
适配专用芯片的模型压缩
部署
TensorRT
后续
- tensorrt完整demo
- 其他压缩算法(量化/剪枝/蒸馏/NAS等)
- 其他部署框架(mnn/tnn/tengine等)
- 压缩 —> 部署
常见问题
相似工具推荐
openclaw
OpenClaw 是一款专为个人打造的本地化 AI 助手，旨在让你在自己的设备上拥有完全可控的智能伙伴。它打破了传统 AI 助手局限于特定网页或应用的束缚，能够直接接入你日常使用的各类通讯渠道，包括微信、WhatsApp、Telegram、Discord、iMessage 等数十种平台。无论你在哪个聊天软件中发送消息，OpenClaw 都能即时响应，甚至支持在 macOS、iOS 和 Android 设备上进行语音交互，并提供实时的画布渲染功能供你操控。 这款工具主要解决了用户对数据隐私、响应速度以及“始终在线”体验的需求。通过将 AI 部署在本地，用户无需依赖云端服务即可享受快速、私密的智能辅助，真正实现了“你的数据，你做主”。其独特的技术亮点在于强大的网关架构，将控制平面与核心助手分离，确保跨平台通信的流畅性与扩展性。 OpenClaw 非常适合希望构建个性化工作流的技术爱好者、开发者，以及注重隐私保护且不愿被单一生态绑定的普通用户。只要具备基础的终端操作能力（支持 macOS、Linux 及 Windows WSL2），即可通过简单的命令行引导完成部署。如果你渴望拥有一个懂你
stable-diffusion-webui
stable-diffusion-webui 是一个基于 Gradio 构建的网页版操作界面，旨在让用户能够轻松地在本地运行和使用强大的 Stable Diffusion 图像生成模型。它解决了原始模型依赖命令行、操作门槛高且功能分散的痛点，将复杂的 AI 绘图流程整合进一个直观易用的图形化平台。 无论是希望快速上手的普通创作者、需要精细控制画面细节的设计师，还是想要深入探索模型潜力的开发者与研究人员，都能从中获益。其核心亮点在于极高的功能丰富度：不仅支持文生图、图生图、局部重绘（Inpainting）和外绘（Outpainting）等基础模式，还独创了注意力机制调整、提示词矩阵、负向提示词以及“高清修复”等高级功能。此外，它内置了 GFPGAN 和 CodeFormer 等人脸修复工具，支持多种神经网络放大算法，并允许用户通过插件系统无限扩展能力。即使是显存有限的设备，stable-diffusion-webui 也提供了相应的优化选项，让高质量的 AI 艺术创作变得触手可及。
everything-claude-code
everything-claude-code 是一套专为 AI 编程助手（如 Claude Code、Codex、Cursor 等）打造的高性能优化系统。它不仅仅是一组配置文件，而是一个经过长期实战打磨的完整框架，旨在解决 AI 代理在实际开发中面临的效率低下、记忆丢失、安全隐患及缺乏持续学习能力等核心痛点。 通过引入技能模块化、直觉增强、记忆持久化机制以及内置的安全扫描功能，everything-claude-code 能显著提升 AI 在复杂任务中的表现，帮助开发者构建更稳定、更智能的生产级 AI 代理。其独特的“研究优先”开发理念和针对 Token 消耗的优化策略，使得模型响应更快、成本更低，同时有效防御潜在的攻击向量。 这套工具特别适合软件开发者、AI 研究人员以及希望深度定制 AI 工作流的技术团队使用。无论您是在构建大型代码库，还是需要 AI 协助进行安全审计与自动化测试，everything-claude-code 都能提供强大的底层支持。作为一个曾荣获 Anthropic 黑客大奖的开源项目，它融合了多语言支持与丰富的实战钩子（hooks），让 AI 真正成长为懂上
ComfyUI
ComfyUI 是一款功能强大且高度模块化的视觉 AI 引擎，专为设计和执行复杂的 Stable Diffusion 图像生成流程而打造。它摒弃了传统的代码编写模式，采用直观的节点式流程图界面，让用户通过连接不同的功能模块即可构建个性化的生成管线。 这一设计巧妙解决了高级 AI 绘图工作流配置复杂、灵活性不足的痛点。用户无需具备编程背景，也能自由组合模型、调整参数并实时预览效果，轻松实现从基础文生图到多步骤高清修复等各类复杂任务。ComfyUI 拥有极佳的兼容性，不仅支持 Windows、macOS 和 Linux 全平台，还广泛适配 NVIDIA、AMD、Intel 及苹果 Silicon 等多种硬件架构，并率先支持 SDXL、Flux、SD3 等前沿模型。 无论是希望深入探索算法潜力的研究人员和开发者，还是追求极致创作自由度的设计师与资深 AI 绘画爱好者，ComfyUI 都能提供强大的支持。其独特的模块化架构允许社区不断扩展新功能，使其成为当前最灵活、生态最丰富的开源扩散模型工具之一，帮助用户将创意高效转化为现实。
gemini-cli
gemini-cli 是一款由谷歌推出的开源 AI 命令行工具，它将强大的 Gemini 大模型能力直接集成到用户的终端环境中。对于习惯在命令行工作的开发者而言，它提供了一条从输入提示词到获取模型响应的最短路径，无需切换窗口即可享受智能辅助。 这款工具主要解决了开发过程中频繁上下文切换的痛点，让用户能在熟悉的终端界面内直接完成代码理解、生成、调试以及自动化运维任务。无论是查询大型代码库、根据草图生成应用，还是执行复杂的 Git 操作，gemini-cli 都能通过自然语言指令高效处理。 它特别适合广大软件工程师、DevOps 人员及技术研究人员使用。其核心亮点包括支持高达 100 万 token 的超长上下文窗口，具备出色的逻辑推理能力；内置 Google 搜索、文件操作及 Shell 命令执行等实用工具；更独特的是，它支持 MCP（模型上下文协议），允许用户灵活扩展自定义集成，连接如图像生成等外部能力。此外，个人谷歌账号即可享受免费的额度支持，且项目基于 Apache 2.0 协议完全开源，是提升终端工作效率的理想助手。
markitdown
MarkItDown 是一款由微软 AutoGen 团队打造的轻量级 Python 工具，专为将各类文件高效转换为 Markdown 格式而设计。它支持 PDF、Word、Excel、PPT、图片（含 OCR）、音频（含语音转录）、HTML 乃至 YouTube 链接等多种格式的解析，能够精准提取文档中的标题、列表、表格和链接等关键结构信息。 在人工智能应用日益普及的今天，大语言模型（LLM）虽擅长处理文本，却难以直接读取复杂的二进制办公文档。MarkItDown 恰好解决了这一痛点，它将非结构化或半结构化的文件转化为模型“原生理解”且 Token 效率极高的 Markdown 格式，成为连接本地文件与 AI 分析 pipeline 的理想桥梁。此外，它还提供了 MCP（模型上下文协议）服务器，可无缝集成到 Claude Desktop 等 LLM 应用中。 这款工具特别适合开发者、数据科学家及 AI 研究人员使用，尤其是那些需要构建文档检索增强生成（RAG）系统、进行批量文本分析或希望让 AI 助手直接“阅读”本地文件的用户。虽然生成的内容也具备一定可读性，但其核心优势在于为机器