R. Z. Blog

第三代博客：Astro + Firefly 的迁移与改造记录

Sat, 01 Aug 2026 00:00:00 GMT

AI 生成声明

本文由 AI 根据建站过程中的实际改动整理生成，可能存在表述偏差或遗漏；请以仓库中的真实代码与配置为准。

写在前面

本站已迭代到第三代：WordPress → Hexo + NexT → Astro + Firefly。本文只记「为了把主题变成自己的站」实际动过哪些地方，方便以后升级上游时对照，不当作通用教程。

为什么再换一次#

前两代各自解决过当时的问题：WordPress 上手快、后台可视化；Hexo 静态部署省心，NexT 也改得顺手。换 Astro 主要不是为了「更好看」，而是扩展性：

	WordPress	Hexo + NexT	Astro + Firefly
写文	后台编辑	Markdown	Markdown / MDX
交互	插件 / PHP	嵌脚本别扭	岛屿组件，局部 React/Svelte 自然
运维	服务器与更新	`hexo g && deploy`	`pnpm build` + 静态托管
适合	早期个人站	论文笔记 + 机制文	博客 + 以后挂小工具

机制计算器、文内嵌组件这类需求，在 Hexo 里硬塞主题不如在 Astro 里直接做页面。Firefly 基于 Fuwari，配置集中在 src/config/*，多数「换皮」不用先动源码。

官方文档：Firefly Docs。

改动分层#

层级	做什么	典型路径
配置	站点身份、导航、页面开关、评论、壁纸	`src/config/*.ts`
文案 / 资源	About、Favicon、头像、演示文清理	`src/content/spec/`、`public/`、`src/assets/`
主题小改	表格、目录、About 公式、Dark Reader	`markdown.css`、`toc-*.ts`、`about.astro`、`Layout.astro`
内容	旧文迁移与 frontmatter 对齐	`src/content/posts/`、`scripts/wp_to_md.py`

原则：能配就不改主题；只有默认行为卡住正文排版时，再动 CSS / 工具函数。

一、配置层：从 Demo 变成个人站#

站点身份#

主要在 siteConfig.ts / profileConfig.ts：

标题、副标题、描述、关键词换成自己的文案
site_url 先指向现有域名（后续可随正式上线再改）
siteStartDate 接到更早的建站日期，页脚运行天数才有意义
主题色相、卡片边框 / 跟随主题色、文章卡片摘要行数、瀑布流等按阅读习惯微调
提醒框主题改为 VitePress 风格（rehypeCallouts.theme），和论文笔记里的 callout 观感更贴近
头像、导航 Logo、Favicon 换成自己的图（Favicon 需落在 public/ 下才能被浏览器正确加载）

页面与导航做减法#

Firefly 默认打开友链、打赏、番组、相册、追番、动态等。本站暂不需要，在 siteConfig.pages 里关掉对应开关；导航里主题自带的「链接」子菜单也注释掉，避免首页还像官方演示站。

侧栏改为偏左侧布局，关掉公告组件，减少干扰。

评论：Twikoo#

评论与站点托管可以分开部署。前端在 commentConfig.ts：

type: "twikoo"
envId 必须是自己的云函数地址，不能用官方演示 twikoo.vercel.app

Firefly 对 Twikoo 有现成主题样式，观感比硬改 Waline 省事。后端仍需自建（常见是 MongoDB Atlas + Vercel / Netlify 等），部署成功页应显示「Twikoo 云函数运行正常」，再把该 URL 填进 envId。

字体等杂项#

按个人喜好在 fontConfig.ts 增加了 Lato；壁纸、页脚 HTML、音乐等也在对应配置里换成自己的资源或文案。这些都属于「换皮」，升级上游时冲突通常好解决。

二、主题小改：几处真正动到的代码#

配置解决不了、又直接影响阅读体验的，目前主要是下面几处。

1. About 页公式：补上 KaTeX 样式#

About 写在 src/content/spec/about.md，可以用 $...$ / $$...$$。文章页会引入 KatexManager（加载 katex.min.css），About 页原先没有，于是可见的 HTML 排版和无障碍 MathML 叠在一起，公式看起来像重复了一截。

处理：在 src/pages/about.astro 与文章页对齐，加上：

1
<KatexManager slot="head" />

TIP

以后凡是走 spec 或自定义页面、又要用数学公式的，都要确认是否引入了 KatexManager，不要只以为「Markdown 里写了公式就会自动漂亮」。

2. 表格：按容器宽度自适应#

指挥喵等机制文表格列数多。Firefly 默认大致是：

表格 width: max-content
单元格 min-width: 120px

结果很容易超出正文栏，再被包进横向滚动容器。论文 / 数据表更希望「铺满卡片宽度、长文换行」。

在 src/styles/markdown.css 中调整为：

表格 width: 100%，随正文宽度走
去掉强制 min-width: 120px，允许列收缩
overflow-wrap: anywhere 处理超长单元格
尊重 Markdown 对齐语法生成的 align="center|left|right"（原先全局 text-left 会盖掉 :---:）
表格内图标统一 inline-block + 垂直居中，仅含图标的列适当收窄

若某篇极宽表仍想横向滚动，可以再局部覆盖；当前默认优先适配本站常见的多列表格。

3. 目录：排除 GFM「Footnotes」#

论文笔记大量使用 [^slug] 脚注。GFM 会在文末自动插入类似：

1
<section class="footnotes">
2
  <h2 id="footnote-label">Footnotes</h2>
3
  ...
4
</section>

侧栏 TOC 会收集正文标题，于是目录末尾多出一个英文 Footnotes，和手写的「参考文献」叠床架屋。

在 toc-shared.ts（构建期 headings）和 toc-utils.ts（客户端收集标题）里，把 footnote-label / 文案为 Footnotes·脚注 / .footnotes 内标题从目录中滤掉。正文脚注列表仍保留。

4. Dark Reader：官方 lock#

Firefly 已自带亮 / 暗色主题（html.dark、半透明 overlay、彩色 callout 等）。若访客同时开启浏览器扩展 Dark Reader，扩展会再染一遍颜色，容易出现壁纸半透明层发黑块、Admonition 色调发脏等问题。

处理很轻：在 Layout.astro 的 <head> 加入 Dark Reader 官方 opt-out：

1
<meta name="darkreader-lock" />

扩展识别到后会对本页停用动态改色，无需再做检测弹窗。站点暗色仍用主题内置开关即可。

三、内容迁移#

Frontmatter 要对齐 Firefly#

Hexo 常见字段和 Firefly 不完全一致，迁移时统一成例如：

1
title: ...
2
published: YYYY-MM-DD
3
description: ...
4
category: ...
5
tags: [...]
6
slug: ...
7
draft: false

注意：categories → category；日期用 published 而不是 date；摘要优先写在 description，不必依赖 Hexo 的 。

提醒框尽量用主题已支持的 callout（如 [!NOTE]），少依赖旧主题的 HTML 标签。行内小图标、彩色标注等，在 Markdown 能力不够时仍可用少量 HTML，但尽量把「样式规则」收到主题 CSS，避免每篇文章复制内联 style。

来源与脚本#

Hexo 文：按篇迁到 src/content/posts/，并按上面格式整理（量化笔记、MD5 笔记、碧蓝机制文等）。
WordPress 导出（WXR）：用仓库内 scripts/wp_to_md.py 转成 Markdown（处理 Gutenberg 块、[latex]、[crayon] 等），再人工扫一遍草稿与空文。

主题自带的演示文章已挪到 firefly_draft/ 或不再作为正式内容展示，避免首页仍像官方 Demo。

图床外链（如长期稳定的图床 URL）可继续用；旧 WordPress 域名下的图片若站点已下线，需要另迁，本文不展开。

四、部署侧（与主题改动正交）#

构建：项目要求 pnpm；pnpm install && pnpm build，产物在 dist。
静态托管即可（GitHub Pages、EdgeOne Pages、Netlify、Vercel 等）；不要为了纯静态站误开仅 Cloudflare Workers 才需要的环境变量。
站点托管 ≠ 评论后端：博客在 A 平台、Twikoo 在 B 平台完全可行。

具体域名与 CDN 以实际上线配置为准；换域名时记得同步 site_url 与评论回调相关设置。

五、升级上游时怎么复查#

从上游 Firefly 拉新版本时，建议优先核对：

src/config/* 是否被示例配置覆盖（用自己的配置文件或合并工具仔细 diff）
markdown.css 表格相关规则是否被还原
toc-shared.ts / toc-utils.ts 的脚注过滤是否还在
about.astro 是否仍引入 KatexManager
Layout.astro 是否仍含 <meta name="darkreader-lock" />
commentConfig 的 envId 是否仍指向自己的后端

内容目录与 scripts/wp_to_md.py 一般不在上游范围内，冲突较少。

小结#

这轮迁站的过程中，大部分工作是配置与内容，真正改主题源码的主要是：About 补 KaTeX、表格自适应与对齐、TOC 排除脚注标题，以及 darkreader-lock。其余是关掉用不到的页面、换上自己的身份与评论后端、把旧站 Markdown / WXR 收进 Firefly 的 frontmatter 约定。

碧蓝航线大型作战 - 指挥喵物资搜寻

Mon, 01 Sep 2025 00:00:00 GMT

指挥喵物资搜寻游戏帮助页面

本文的所有内容均基于以下基本假设：

假设 0.1 碧蓝航线游戏内所有大型作战相关的数据，无论是客户端或是服务器端的数据，均不会随游戏版本更新、游戏账号状态变化而发生变动。
假设 0.2 碧蓝航线游戏内所有大型作战相关的随机事件均为相互独立的随机事件，且事件概率的数值均为有理数。

本文对于估计的数值的可信程度分为三个等级：

高可信度：数值字体为蓝色，表示该数值经过大量数据统计与分析、统计数据的样本量足够大、最终的估计值贴近常见的整数/分数形式、估计概率与统计频率的偏差较小；
中可信度：数值字体为橙色，表示该数值在统计数据中出现的数量较少、估计概率与统计频率的偏差较大、估计概率存在一定的主观成分；
低可信度：数值字体为红色，表示该数值在统计数据中出现的数量极少、估计概率与统计频率的偏差非常大、估计概率存在较大的主观成分。

基本介绍#

指挥喵物资搜寻点是碧蓝航线大型作战地图中的一种特殊资源节点，玩家可以在该节点派遣当前舰队携带的指挥喵离队进行物资搜寻，在移动一定步数之后获取随机资源奖励。

指挥喵物资搜寻点会在大型作战的危险海域、安全海域、隐秘海域和塞壬要塞海域随机或固定出现。

从游戏官方的帮助界面可以了解到，指挥喵的稀有度与等级都会影响搜寻奖励。有关指挥喵的稀有度和等级对搜寻奖励的影响，官方并未给出具体的数值说明，在各论坛和攻略中也未见有相关的统计数据。一般认为，当前舰队的司令位置指挥喵的稀有度为 SSR、等级为 30 级时，搜寻奖励可以达到最高。本文默认搜寻奖励均为最高级。搜寻奖励为最高级时，每个指挥喵物资搜寻点可以搜寻到 8 个掉落物品。

在游戏文件 world_catsearch_node 中，可以看到有 1xx、2xx、3xx、4xx 四种编号类型的指挥喵物资搜寻掉落物品，每类编号分别对应着不同的海域类型。每类编号的掉落物品种类和所有属性相同，但掉落概率未知，这里提出以下假设：

假设 1.1 不同海域的指挥喵物资搜寻点的最高级奖励掉落物品种类及其概率均相同，且每次掉落物品都是独立的随机事件。

基于该假设，本文将对指挥喵物资搜寻点的掉落物品以及各种属性进行统计与分析。

掉落物品的种类#

在游戏中，当开始指挥喵物资搜寻时，可以点击游戏界面的指挥喵搜寻图标，在搜寻奖励查询界面中查看当前指挥喵物资搜寻点的掉落物品种类。指挥喵物资搜寻点最高级搜寻奖励共有 20 种掉落物品。在游戏文件 world_catsearch_node 中，将所有项根据首位编号分组，可以获得各个海域所对应的指挥喵物资搜寻的 20 种掉落物品的掉落事件 ID、得分、搜寻所需行动步数、TB 提示特殊掉落等属性。物品 ID 可以在游戏文件 gameset 的 world_catsearchdrop_show 项中查询到，其对应的名称需要在文件 world_item_data_template 中查找。所有 20 种掉落物品如下：

未知装备研发图纸UR型
特装型突破部件
塞壬坐标记录仪R6
未知装备研发图纸SSR型
试作型突破部件
未知装备部件T4
机密实验计划
装备研发物资箱T3
喵箱SSR型
塞壬坐标记录仪R5
塞壬坐标记录仪R4
海域坐标记录仪R6
海域坐标记录仪R5
常规实验计划
装备研发物资箱T2
喵箱SR型
装备研发物资箱T1
特别兑换凭证
作战补给凭证
物资

其中，未知装备研发图纸UR型、未知装备研发图纸SSR型、未知装备部件T4、装备研发物资箱T3、装备研发物资箱T2、装备研发物资箱T1 这些掉落物品在获取时会随机掉落其对应的具体物品。例如，在每次掉落未知装备部件T4 时，会从通用部件T4、主炮部件T4、鱼雷部件T4、防空炮部件T4、舰载机部件T4 中随机选择一项作为实际获得的物品。如果将所有父类物品的子类物品都展开看作独立的掉落物品，则指挥喵物资搜寻点最高级搜寻奖励共有 43 种可能的掉落物品。所有父类物品及其对应的子类物品如下：

未知装备研发图纸UR型：主炮设计图纸UR型、鱼雷设计图纸UR型、防空炮设计图纸UR型、舰载机设计图纸UR型
未知装备研发图纸SSR型：主炮设计图纸SSR型、鱼雷设计图纸SSR型、防空炮设计图纸SSR型、舰载机设计图纸SSR型
未知装备部件T4：通用部件T4、主炮部件T4、鱼雷部件T4、防空炮部件T4、舰载机部件T4
装备研发物资箱T3：特种钢材、军工级电子元件、HBX炸药、氟橡胶、超导铜、钛合金
装备研发物资箱T2：优质钢材、工业级电子元件、B炸药、通用合成橡胶、铜锭、铝合金
装备研发物资箱T1：普通钢材、通常电子元件、常规炸药、天然橡胶

掉落物品的数量#

特别兑换凭证、作战补给凭证、物资这些货币类物品在掉落时的数量是随机的。对于任意货币类物品，其掉落数量服从正整数上的离散均匀分布。所有货币类物品及其对应的单次的掉落数量如下：

特别兑换凭证：范围 [1, 3]，即 random.randint(1, 3)，单次掉落期望为 2；
作战补给凭证：范围 [50, 100]，即 random.randint(50, 100)，单次掉落期望为 75；
物资：范围 [10, 20]，即 random.randint(10, 20)，单次掉落期望为 15。

除了货币类物品的掉落数量是随机的，其它所有掉落物品单次的掉落数量均为 1。

掉落物品的搜寻步数#

搜寻步数是指在指挥喵物资搜寻过程中，搜寻到该掉落物品所需要的舰队行动步数。在进行指挥喵物资搜寻时，当前搜寻进度，即已掉落的物品次数，会在左下角的指挥喵图标上显示。每次舰队行动后会累计一次搜寻步数。有时，舰队行动后搜寻进度并未增加，这说明当前搜寻到的掉落物品需要的搜寻步数还未达到。只有当累计的搜寻步数达到该掉落物品所需的搜寻步数时，才会掉落该物品，搜寻进度才会增加一次。越稀有的物品通常需要越多的搜寻步数。所有掉落物品的搜寻步数可以在游戏文件 world_catsearch_node 中查询字段 step 得到。该属性仅用于游戏内掉落物品时的演示效果，仅依赖于已掉落物品本身，对物品的掉落概率和数量无影响。所有掉落物品的搜寻步数见下文的总表。

掉落物品的 TB 提示#

TB 提示是指在指挥喵物资搜寻过程中，当累计的搜寻步数达到该掉落物品所需的搜寻步数时，是否会有 TB 出现并进行文字提示。TB 提示的掉落物品通常为较为稀有的物品。所有掉落物品的 TB 提示可以在游戏文件 world_catsearch_node 中查询字段 special_drop 得到。该属性仅用于游戏内掉落物品时的演示效果，仅依赖于掉落物品本身，对物品的掉落概率和数量无影响。所有掉落物品的 TB 提示见下文的总表。

掉落物品的得分#

得分是指挥喵物资搜寻点掉落物品的一个隐藏属性。每次搜寻到物品时，都会根据该物品的得分来累计当前指挥喵物资搜寻点的总得分，总得分会影响最终指挥喵物资搜寻结果的评级。评级共分为 R、SR、SSR 三个等级，在游戏中分别以蓝色、紫色、金色猫爪图标显示。货币类物品的随机数量不影响其单次掉落的得分。所有掉落物品的得分均可以在游戏文件 world_catsearch_node 中查询字段 score 得到。各评级的总得分范围可以在游戏文件 gameset 的 world_catsearch_score 项中查询到。具体如下：

R 级：(0, 29]
SR 级：[30, 69]
SSR 级：[70, +∞)

该属性仅用于游戏内掉落物品时的演示效果，仅依赖于掉落物品本身，对物品的掉落概率和数量无影响。所有掉落物品的得分见下文的总表。

掉落物品的概率#

掉落物品的概率属于服务器端的隐藏属性，官方并未公开该属性。基于前面提出的假设，本文对所有掉落物品的概率进行统计与分析。

所有统计数据样本均来自 2024-08-06 至 2025-09-08 期间，由 2 个游戏账号在碧蓝航线大型作战的危险海域、安全海域、隐秘海域和塞壬要塞海域完成的完整过程的指挥喵物资搜寻。统计数据共包含 20377 条样本。每个样本的格式为使用自律寻敌完成指挥喵物资搜寻后的掉落物品结算界面的截图。每张截图都包含了 1 或 2 次指挥喵物资搜寻的完整掉落物品信息。

对于 100% 的样本，保证执行指挥喵物资搜寻舰队的司令位置指挥喵的稀有度为 SSR、等级为 30 级；
对于 >99% 的样本，保证执行指挥喵物资搜寻舰队的参谋位置指挥喵的稀有度至少为 SSR、等级至少为 25 级。

本文统计了每种掉落物品的频率，并分析了相似物品之间的比例关系，最终对每种物品的概率进行近似估计。对于掉落概率非常低的物品，可能需要更多的统计数据才能得到更准确的估计概率。

掉落物品的概率估计#

所有 20 种掉落物品随统计数据样本数增加而得到的累计频率曲线如下图所示。

指挥喵物资搜寻掉落物品概率估计

其中：每个子图对应一种掉落物品。标题后的数字表示该物品的经过估计后的概率。蓝色实曲线表示该物品的累计频率随统计数据样本数增加而变化的趋势，大部分物品的累计频率曲线趋于平稳；两条红色水平虚线表示该物品掉落频率在置信水平为 99% 时的置信区间上限和下限；绿色水平虚线表示该物品在所有统计数据样本中出现的频率，即掉落总数 / 指挥喵物资搜寻总数 / 8。在每张截图的自律寻敌结束后的掉落物品结算界面中，货币类物品的数量是多次随机数量叠加的结果。本文在统计货币类物品时，将最终的数量除以该货币类物品单次掉落数量的数学期望，即特别兑换凭证 2、作战补给凭证 75、物资 15，作为该货币类物品的掉落次数；对于其它非货币类物品，直接将其总数作为掉落次数。

相似物品的比例关系#

在所有掉落物品种类中，有一些物品存在较为明显的相似性。例如，未知装备研发图纸UR型 和 未知装备研发图纸SSR型 都是研发图纸类物品，塞壬坐标记录仪R6、塞壬坐标记录仪R5、塞壬坐标记录仪R4 都是塞壬坐标记录仪类物品，等等。本文选择以下 8 组物品进行组内物品间比例关系的分析，每组组内物品总体占比如下图所示：

指挥喵物资搜寻分组掉落物品比例关系

每组组内物品的比例关系估计值如下：

装备研发物资箱T3：装备研发物资箱T2：装备研发物资箱T1 = 10 : 50 : 41
未知装备研发图纸UR型：未知装备研发图纸SSR型 = 2 : 15
喵箱SSR型：喵箱SR型 = 1 : 5
塞壬坐标记录仪R6：塞壬坐标记录仪R5：塞壬坐标记录仪R4 = 2 : 5 : 8
海域坐标记录仪R6：海域坐标记录仪R5 = 3 : 7
机密实验计划：常规实验计划 = 3 : 5
特装型突破部件：试作型突破部件 = 1 : 3
作战补给凭证：特别兑换凭证：物资 = 25 : 12 : 10

这些比例关系均为估计值，并不能反映服务器端是否真实存在这些比例关系。由于货币类物品的掉落数量是随机的，且统计频率的浮动较大，在估计它们的概率时，本文使用了以上比例关系作为参考，即总概率 (100%) 减去其它 17 种物品的概率之和后，剩余概率 (70.785%) 按比例关系 25 : 12 : 10 分配给作战补给凭证、特别兑换凭证、物资。其它单次掉落数量为 1 的部分物品的概率估计也参考了上述相似物品的比例关系。

子类物品的比例关系#

指挥喵物资搜寻点所展示的 20 种掉落物品中，有 6 种物品属于父类物品，其实际掉落时会随机获得其对应的子类物品中的一种。本文对所有父类物品的子类物品的比例关系进行了统计与分析。所有父类物品及其对应的子类物品总体占比如下图所示：

指挥喵物资搜寻子类掉落物品比例关系

从图中可以看出，各父类物品的子类物品的比例关系均较为平均。因此，在估计各子类物品的概率时，可以将其父类物品的概率按对应子类物品的种类数量均分。

货币类物品的随机数量范围#

上文提到，特别兑换凭证、作战补给凭证、物资这些货币类物品在掉落时的数量是随机的。根据过往游戏中其它随机事件的随机数生成统计结果所积累的经验，前文直接推测这些货币类物品的随机数量均服从正整数上的离散均匀分布。为了验证该推测，本文统计了所有数据样本中这三种货币类物品的掉落数量的分布情况，结果如下图所示：

指挥喵物资搜寻货币类掉落物品数量分布

其中，直方图中蓝色柱表示各掉落数量的实际频数，黄色柱表示各掉落数量的模拟频数。模拟频数是基于前文推测的均匀分布假设，利用已估计的单次掉落概率，经过与统计数据中各货币物品掉落次数相等的次数模拟计算得到的。可以看出，实际频数与模拟频数的分布图大致吻合。因此，可以认为前文的均匀分布假设是合理的。

掉落物品的综合属性总表#

综上所述，本文对指挥喵物资搜寻点最高级搜寻奖励的 20 种掉落物品的各种属性进行了统计与分析。所有掉落物品的属性总表如下：

名称	稀有度	搜寻步数	TB 提示	得分	单次估计概率 (%)	单次数量
未知装备研发图纸UR型	UR	3	√	40	0.080	1
特装型突破部件	UR	3	√	40	0.100	1
塞壬坐标记录仪R6	UR	3	√	40	0.010	1
未知装备研发图纸SSR型	SSR	2	√	20	0.600	1
试作型突破部件	SSR	2	√	20	0.300	1
未知装备部件T4	SSR	2	×	15	1.500	1
机密实验计划	SSR	2	√	25	0.300	1
装备研发物资箱T3	SSR	2	×	15	2.400	1
喵箱SSR型	SSR	3	√	40	0.200	1
塞壬坐标记录仪R5	SSR	3	√	40	0.025	1
塞壬坐标记录仪R4	SSR	3	√	30	0.040	1
海域坐标记录仪R6	SSR	3	√	30	0.048	1
海域坐标记录仪R5	SSR	3	√	30	0.112	1
常规实验计划	SR	2	×	10	0.500	1
装备研发物资箱T2	SR	1	×	5	12.000	1
喵箱SR型	SR	2	×	10	1.000	1
装备研发物资箱T1	R	1	×	1	10.000	1
特别兑换凭证	SR	1	×	5	18.073	[1, 3]
作战补给凭证	R	1	×	1	37.651	[50, 100]
物资	N	1	×	1	15.061	[10, 20]

参考文献#

素材来源#

GitHub - AzurLaneAssets

Hessian-based Post-Training Quantization

Tue, 15 Mar 2022 00:00:00 GMT

阅读说明

个人论文阅读报告留档：基于 Hessian 矩阵的 PTQ 后训练量化算法系列论文：AdaRound（ICML 2020）、BRECQ（ICLR 2021）、QDrop（ICLR 2022）。

引言#

问题背景#

2012 年，AlexNet 在 ILSVRC 比赛上大放异彩，人工智能也随之走入了以深度学习技术为主的新的发展时期。在之后的几年里，基于深度学习的算法或模型在任务上的性能改进都与模型的参数量成正相关。复杂的模型的计算时间和空间复杂度都很高，在资源受限的硬件上部署仍然具有很大挑战。

图 1 深度神经网络参数量随年代增长变化曲线

神经网络量化的基本概念#

量化#

量化（Quantization）这一概念源自通信和信息学领域，是指一种从大（通常是连续）范围的输入值映射到（通常是离散）范围的输出值的方法。在数值计算问题中，量化问题指一组连续的实数值应该如何映射到一组取值固定的离散数值集合上，从而能够最大限度地减少数值表示所需的位数并最大限度地提高计算的精度。近年来，由于基于深度学习的神经网络模型的复杂度不断提高，对神经网络的量化问题的研究逐渐成为人工智能技术应用和神经网络计算优化的重要子领域。
针对深度神经网络的量化一般有两个目的：网络压缩和推理加速。网络压缩指通过降低模型参数（包括权重和激活值）的数值表示所需的位数，达到降低内存容量和带宽的效果，例如将一个参数全部是 32 位浮点数的神经网络的权重和激活值全部量化到 8 位整型数值，其内存占用和带宽理论上均可减少至原来的四分之一。而实现推理加速则是利用量化从高精度映射到低精度数值表示的特性，进行进一步的低精度（如整型）的计算优化，减少模型计算推理的时间，例如对 8 位整型数的乘法运算进行优化，可以理论上实现相比 32 位浮点数的乘法运算的速度快 16 倍的加速效果。
量化时的浮点数离散化操作会造成精度损失，因此在量化操作之后得到的值会与原真实值存在差异，这个差异叫作量化误差（Quantization Error）。直观上来说，将全精度的数值映射为低精度的数值会不可避免地导致信息丢失，这个过程中会对神经网络模型引入量化误差，导致模型预测精度的下降。但是实际上许多量化神经网络的表现与原始神经网络相差无几。关于量化误差与模型预测精度的相关性，目前尚未出现严谨的理论证明。一个可能的解释是：当前多数神经网络模型都存在严重的参数冗余，模型参数的自由度较高，因此对于参数的量化具有较高的鲁棒性。

图 2 神经网络量化的模型压缩和加速

量化的数学表示#

量化可以表示为一个映射函数 QQQ，该函数将输入的浮点数值集合 XXX 映射到离散的数值集合 YYY。函数 QQQ 在过去的研究中有多种实现方式，其中使用得最为广泛的是对称仿射量化（Symmetric Affine Quantization），或者叫作对称线性量化（Symmetric Linear Quantization）。对称线性量化的一般形式如下：

Q(x)=clip(round(xs))x^=s⋅Q(x)\begin{align*} &Q(\mathbf{x}) = \text{clip}\left(\text{round}\left(\frac{\mathbf{x}}{s}\right)\right)\\\\ &\hat{\mathbf{x}} = s \cdot Q(\mathbf{x}) \end{align*}Q(x)=clip(round(sx))x^=s⋅Q(x)

对于某一粒度规模（Layer-wise 或者 Channel-wise）的参数，对称线性量化使用一个缩放系数 sss 来调整原始集合的数值范围到固定的数值范围，然后经过舍入 round\text{round}round 和截断 clip\text{clip}clip 的方式实现取值的离散化，最后重新使用缩放系数 sss 来恢复到原始集合的数值范围。使用对称线性量化的好处是：在求解量化问题时需要优化的参数只有量化的缩放系数 sss，并且量化神经网络在实际进行乘法运算时，可以提取出计算过程中不同的缩放系数 sss，先进行低精度的整数乘法，然后统一进行缩放运算，这样可以简化运算，实现计算加速效果，如图 3 所示。

图 3 伪量化和真实量化计算示意图

后训练量化和量化感知训练#

后训练量化（Post-Training Quantization, PTQ），又称离线量化，指的是将一个预训练的神经网络模型通过参数优化等方法获得一个量化的神经网络模型，一般不会涉及网络的再训练过程。离线量化方法可以快速获取一个量化模型，可以节省训练所需的计算资源，并且更适合快速迭代的应用场景。针对激活值的离线量化需要使用一个小规模的数据集作为校准集（Calibration Dataset），通过对校准集进行推理来统计激活值的数值范围，从而实现对激活的量化优化。
量化感知训练（Quantization-Aware Training，QAT），又称在线量化。与离线量化不同，在线量化将量化映射函数事先插入到模型的计算图中需要被量化的参数的位置，并对模型使用完整的训练集进行训练。再训练过程不仅会优化原始任务的损失，同时也会优化量化误差带来的量化损失。使用量化感知训练得到的量化模型通常比后训练量化得到的模型的预测准确度更高，但需要消耗大量的计算资源，并且超参数的设定也会对量化模型的收敛产生影响。

图 4 后训练量化与量化感知训练在数据和训练两个维度的区别

Hessian 矩阵#

海森矩阵（Hessian Matrix），或称作黑塞矩阵、海瑟矩阵等，是由多元函数的二阶偏导数构成的方阵。对于复杂的优化问题，其目标函数往往较为复杂。为了使问题简化，可以将目标函数在某点的邻域进行二阶泰勒展开（Taylor Expansion）来逼近原函数，其中的二阶项就包含 Hessian 矩阵。
例如，对于一个多元函数 F(x)\mathcal{F}(\mathbf{x})F(x)，其在点 x0\mathbf{x}_0x0 处的二阶泰勒展开可以表示为：

F(x)≈F(x0)+∇F(x0)T⋅Δx+12ΔxT⋅∇2F(x0)⋅Δx,\begin{align*} \mathcal{F}(\mathbf{x}) \approx \mathcal{F}(\mathbf{x}_0) + \nabla \mathcal{F}(\mathbf{x}_0)^{T} \cdot \Delta \mathbf{x} + \frac{1}{2} \Delta \mathbf{x}^{T} \cdot \nabla^{2} \mathcal{F}(\mathbf{x}_0) \cdot \Delta \mathbf{x}, \end{align*}F(x)≈F(x0)+∇F(x0)T⋅Δx+21ΔxT⋅∇2F(x0)⋅Δx,

其中的二阶偏导数矩阵 H(x)=∇2F(x0)\mathbf{H}^{(\mathbf{x})} = \nabla^{2} \mathcal{F}(\mathbf{x}_0)H(x)=∇2F(x0) 就是 F\mathcal{F}F 在点 x0\mathbf{x}_0x0 处的 Hessian 矩阵，Δx=x−x0\Delta \mathbf{x} = \mathbf{x} - \mathbf{x}_0Δx=x−x0 是 x\mathbf{x}x 相对于 x0\mathbf{x}_0x0 的偏移量。在深度神经网络的优化问题中，Hessian 矩阵可以用来描述损失函数在参数空间中的 Loss landscape。已有的工作例如 PyHessian¹ 通过近似计算 Hessian 矩阵的特征值（Eigenvalue）、迹（Trace），可以获得关于损失函数的二阶信息，从而更好地对不同模型和优化器的性能进行比较和分析。
本次介绍的三篇论文 AdaRound²、BRECQ³、QDrop⁴ 均使用了 Hessian 矩阵来优化量化神经网络模型的性能。

AdaRound#

论文信息

Title: Up or Down? Adaptive Rounding for Post Training Quantization
Venue: ICML 2020
Author(s): Markus Nagel, Rana Ali Amjad, Mart van Baalen, Christos Louizos, Tijmen Blankevoort
Institution(s): Qualcomm AI Research
Link: arXiv:2004.10568

前言#

在进行神经网络的后训练量化时，预训练模型的权重参数 w\mathbf{w}w 和对应的量化缩放系数 s\mathbf{s}s 已经确定，则对于量化误差 Δw\Delta \mathbf{w}Δw 也已确定。假设预训练模型在原始任务上的全局损失为 L(x,y,w)\mathcal{L}(\mathbf{x}, \mathbf{y}, \mathbf{w})L(x,y,w)，其中 x\mathbf{x}x 为输入样本，y\mathbf{y}y 为预测标签或真值，w\mathbf{w}w 为模型参数。将对模型参数 w\mathbf{w}w 的量化看作为对 w\mathbf{w}w 的一个扰动，即 Q(w)=w+ΔwQ(\mathbf{w})=\mathbf{w}+\Delta \mathbf{w}Q(w)=w+Δw。那么，该预训练模型的量化对全局损失的期望及其二阶泰勒展开的近似可以表示为：

E[L(x,y,Q(w))]≈(a)E[ΔwT⋅∇L(x,y,w)+12ΔwT⋅∇2L(x,y,w)⋅Δw]=ΔwT⋅g(w)+12ΔwT⋅H(w)⋅Δw,\begin{align*} & \mathbb{E}[\mathcal{L}(\mathbf{x}, \mathbf{y}, Q(\mathbf{w}))]\\\\ \overset{(a)}{\approx} & \mathbb{E}[\Delta\mathbf{w}^{T} \cdot \nabla \mathcal{L}(\mathbf{x}, \mathbf{y}, \mathbf{w}) + \frac{1}{2} \Delta\mathbf{w}^{T} \cdot \nabla^{2} \mathcal{L}(\mathbf{x}, \mathbf{y}, \mathbf{w}) \cdot \Delta\mathbf{w}]\\\\ = & \Delta \mathbf{w}^{T} \cdot \mathbf{g}^{(\mathbf{w})} + \frac{1}{2} \Delta \mathbf{w}^{T} \cdot \mathbf{H}^{(\mathbf{w})} \cdot \Delta \mathbf{w}, \end{align*}≈(a)=E[L(x,y,Q(w))]E[ΔwT⋅∇L(x,y,w)+21ΔwT⋅∇2L(x,y,w)⋅Δw]ΔwT⋅g(w)+21ΔwT⋅H(w)⋅Δw,

其中 g(w)\mathbf{g}^{(\mathbf{w})}g(w) 为原始任务损失 L\mathcal{L}L 对 w\mathbf{w}w 的一阶偏导数向量，H(w)\mathbf{H}^{(\mathbf{w})}H(w) 为 Hessian 矩阵：

g(w)=E[∇wL(x,y,w)]H(w)=E[∇w2L(x,y,w)].\begin{align*} \mathbf{g}^{(\mathbf{w})} & = \mathbb{E} \left[ \nabla_{\mathbf{w}} \mathcal{L}(\mathbf{x}, \mathbf{y}, \mathbf{w}) \right]\\\\ \mathbf{H}^{(\mathbf{w})} & = \mathbb{E} \left[ \nabla_{\mathbf{w}}^{2} \mathcal{L}(\mathbf{x}, \mathbf{y}, \mathbf{w})\right]. \end{align*}g(w)H(w)=E[∇wL(x,y,w)]=E[∇w2L(x,y,w)].

由于使用的是已训练至收敛的预训练模型，可以假设原任务损失对模型参数 w\mathbf{w}w 的一阶偏导数为 000，即泰勒展开一阶项为 000。常数项也相互抵消。因此，量化对全局损失的期望可以近似用泰勒展开的二阶项来表示：

E[L(x,y,w+Δw)−L(x,y,w)]=12ΔwT⋅H(w)⋅Δw.\mathbb{E}[\mathcal{L}(\mathbf{x}, \mathbf{y}, \mathbf{w} + \Delta \mathbf{w}) - \mathcal{L}(\mathbf{x}, \mathbf{y}, \mathbf{w})] = \frac{1}{2} \Delta \mathbf{w}^{T} \cdot \mathbf{H}^{(\mathbf{w})} \cdot \Delta \mathbf{w}.E[L(x,y,w+Δw)−L(x,y,w)]=21ΔwT⋅H(w)⋅Δw.

这样，针对网络模型参数的量化问题就转化为了对包含 Hessian 矩阵的二次型的优化问题。为了更好地理解这个问题，不妨设 w\mathbf{w}w 包含两个参数 wT=[w1,w2]\mathbf{w}^{T}=[w_{1}, w_{2}]wT=[w1,w2]，对应的量化误差为 ΔwT=[Δw1,Δw2]\Delta \mathbf{w}^{T}=[\Delta w_{1}, \Delta w_{2}]ΔwT=[Δw1,Δw2]，若对应的 Hessian 矩阵为：

H(w)=[10.50.51],\mathbf{H}^{(\mathbf{w})} = \begin{bmatrix} 1 & 0.5 \\\\ 0.5 & 1 \end{bmatrix},H(w)=10.50.51,

则量化误差对全局损失的影响可以表示为：

ΔwT⋅H(w)⋅Δw=Δw12+Δw22+Δw1Δw2,\Delta \mathbf{w}^{T} \cdot \mathbf{H}^{(\mathbf{w})} \cdot \Delta \mathbf{w} = \Delta w_{1}^{2} + \Delta w_{2}^{2} + \Delta w_{1} \Delta w_{2},ΔwT⋅H(w)⋅Δw=Δw12+Δw22+Δw1Δw2,

其中位于 Hessian 矩阵对角线上的二次型项恒为非负，其必然会导致量化误差对全局损失的增加。而 Hessian 矩阵的非对角线项可正可负，会导致量化误差之间的交互作用。若扰动方向相反，则可以使得模型全局损失减小。

图 5 AdaRound 自适应舍入方法主要示意图

AdaRound 提出了一个全新的模型量化算法的优化视角：传统的就近舍入（Round to Nearest）方法会将量化误差 Δw\Delta \mathbf{w}Δw 的每个分量 Δwi\Delta w_{i}Δwi 都舍入到最接近的整数值 Q(Δwi)Q(\Delta w_{i})Q(Δwi)，这并不一定是最优解。如图 5 所示，通过优化量化误差 Δw\Delta \mathbf{w}Δw 的每个分量的舍入方向（Up or Down），可能会使得量化误差对全局损失的影响更小。

方法#

从全局损失到局部损失#

AdaRound 将量化误差对全局损失的影响的期望作为优化目标函数：

arg⁡min⁡Δw E[L(x,y,w+Δw)−L(x,y,w)]\begin{align*} \underset{\Delta \mathbf{w}}{\arg\min} \space \mathbb{E}[\mathcal{L}(\mathbf{x}, \mathbf{y}, \mathbf{w} + \Delta \mathbf{w}) - \mathcal{L}(\mathbf{x}, \mathbf{y}, \mathbf{w})] \end{align*}Δwargmin E[L(x,y,w+Δw)−L(x,y,w)]

该目标函数可以转化为包含 Hessian 矩阵的二次型形式：

arg⁡min⁡Δw(ℓ) E[Δw(ℓ)T⋅H(w)⋅Δw(ℓ)]\begin{align*} \underset{\Delta \mathbf{w} ^{(\ell)}}{\arg\min} \space \mathbb{E}[\Delta {\mathbf{w} ^{(\ell)}} ^{T} \cdot \mathbf{H} ^{(\mathbf{w})} \cdot \Delta \mathbf{w} ^{(\ell)}] \end{align*}Δw(ℓ)argmin E[Δw(ℓ)T⋅H(w)⋅Δw(ℓ)]

对于常见粒度的参数量化而言，其 Hessian 矩阵的规模很大，很难在有限时间内进行计算和求解。AdaRound 对该问题进行了简化。首先，AdaRound 将参数粒度限制在了 Layer-wise 层级，即每次优化只考虑一个参数层的所有参数。对于模型的每一层 ℓ\ellℓ 中的权重参数 W(ℓ)\mathbf{W}^{(\ell)}W(ℓ)，全局损失 L\mathcal{L}L 对其的二阶偏导数可以表示为：

∂2L∂Wi,j(ℓ)∂Wm,o(ℓ)=∂∂Wm,o(ℓ)[∂L∂zi(ℓ)⋅xj(ℓ−1)]=∂2L∂zi(ℓ)∂zm(ℓ)⋅xj(ℓ−1)⋅xo(ℓ−1),\begin{align*} \frac{\partial^{2} \mathcal{L}}{\partial \mathbf{W} _{i,j} ^{(\ell)} \partial \mathbf{W} _{m,o} ^{(\ell)}} & = \frac{\partial}{\partial \mathbf{W} _{m,o} ^{(\ell)}} \left[ \frac{\partial\mathcal{L}}{\partial \mathbf{z} _{i} ^{(\ell)}} \cdot \mathbf{x} _{j} ^{(\ell-1)} \right] \\\\ & = \frac{\partial ^{2} \mathcal{L}}{\partial \mathbf{z} _{i} ^{(\ell)} \partial \mathbf{z} _{m} ^{(\ell)}} \cdot \mathbf{x} _{j} ^{(\ell-1)} \cdot \mathbf{x} _{o}^{(\ell-1)}, \end{align*}∂Wi,j(ℓ)∂Wm,o(ℓ)∂2L=∂Wm,o(ℓ)∂[∂zi(ℓ)∂L⋅xj(ℓ−1)]=∂zi(ℓ)∂zm(ℓ)∂2L⋅xj(ℓ−1)⋅xo(ℓ−1),

那么，损失函数对该层参数的 Hessian 矩阵可以表示为：

H(W(ℓ))=E[x(ℓ−1)⋅x(ℓ−1)T⊗∇z(ℓ)2L],\mathbf{H} ^{(\mathbf{W} ^{(\ell)})} = \mathbb{E} \left[ \mathbf{x} ^{(\ell-1)} \cdot {\mathbf{x} ^{(\ell-1)}} ^{T} \otimes \nabla _{\mathbf{z} ^{(\ell)}} ^{2} \mathcal{L} \right],H(W(ℓ))=E[x(ℓ−1)⋅x(ℓ−1)T⊗∇z(ℓ)2L],

其中 x(ℓ−1)\mathbf{x}^{(\ell-1)}x(ℓ−1) 为上一层的输出激活值，z(ℓ)\mathbf{z}^{(\ell)}z(ℓ) 为该层的预激活值，⊗\otimes⊗ 表示 Kronecker 积。AdaRound 分别基于两个不同的假设对该 Hessian 矩阵进行了简化。

假设一：Hessian 矩阵 H(W(ℓ))\mathbf{H} ^{(\mathbf{W} ^{(\ell)})}H(W(ℓ)) 为对角矩阵，即本层网络的神经元输出相互独立。在此假设下，Hessian 矩阵可以简化为：

H(W(ℓ))=E[x(ℓ−1)⋅x(ℓ−1)T⊗diag(∇z(ℓ)2Li,i)].\mathbf{H} ^{(\mathbf{W} ^{(\ell)})} = \mathbb{E} \left[\mathbf{x} ^{(\ell-1)}\cdot{\mathbf{x} ^{(\ell-1)}} ^{T}\otimes\text{diag}(\nabla _{\mathbf{z} ^{(\ell)}} ^{2}\mathcal{L} _{i,i}) \right].H(W(ℓ))=E[x(ℓ−1)⋅x(ℓ−1)T⊗diag(∇z(ℓ)2Li,i)].

假设二：损失函数 L\mathcal{L}L 对 z(ℓ)\mathbf{z} ^{(\ell)}z(ℓ) 的二阶偏导数是常数，即与输入激活值 x(ℓ−1)\mathbf{x} ^{(\ell - 1)}x(ℓ−1) 无关。因此 ∇z(ℓ)2L\nabla _{\mathbf{z} ^{(\ell)}} ^{2} \mathcal{L}∇z(ℓ)2L 是一个常数矩阵。这样目标函数就省略了加权项，最终简化为对当前层预激活输出的均方误差（Mean Squared Error, MSE）的形式：

arg⁡min⁡ΔWk,:(ℓ)E[∇z(ℓ)2Lk,k⋅ΔWk,:(ℓ)x(ℓ−1)x(ℓ−1)TΔWk,:(ℓ)T]= arg⁡min⁡ΔWk,:(ℓ)ΔWk,:(ℓ)E[x(ℓ−1)x(ℓ−1)T]ΔWk,:(ℓ)T= arg⁡min⁡ΔWk,:(ℓ)E[(ΔWk,:(ℓ)x(ℓ−1))2]\begin{align*} & \underset{\Delta \mathbf{W} _{k,:} ^{(\ell)}}{\arg\min} && \mathbb{E} \left[ \nabla _{\mathbf{z} ^{(\ell)}} ^{2} \mathcal{L} _{k,k} \cdot \Delta \mathbf{W} _{k,:} ^{(\ell)} \mathbf{x} ^{(\ell-1)} {\mathbf{x} ^{(\ell-1)}} ^{T} {\Delta \mathbf{W} _{k,:} ^{(\ell)}} ^{T} \right]\\\\ =\space & \underset{\Delta \mathbf{W} _{k,:} ^{(\ell)}}{\arg\min} && \Delta \mathbf{W} _{k,:} ^{(\ell)} \mathbb{E} \left[ \mathbf{x} ^{(\ell-1)}{\mathbf{x} ^{(\ell-1)}} ^{T} \right] {\Delta \mathbf{W} _{k,:} ^{(\ell)}} ^{T} \\\\ =\space & \underset{\Delta \mathbf{W} _{k,:} ^{(\ell)}}{\arg\min} && \mathbb{E} \left[ \left( \Delta \mathbf{W} _{k,:} ^{(\ell)} \mathbf{x} ^{(\ell-1)} \right) ^{2} \right] \end{align*}= = ΔWk,:(ℓ)argminΔWk,:(ℓ)argminΔWk,:(ℓ)argminE[∇z(ℓ)2Lk,k⋅ΔWk,:(ℓ)x(ℓ−1)x(ℓ−1)TΔWk,:(ℓ)T]ΔWk,:(ℓ)E[x(ℓ−1)x(ℓ−1)T]ΔWk,:(ℓ)TE[(ΔWk,:(ℓ)x(ℓ−1))2]

通过以上对问题的简化，原始的全局损失转化为了每一层预激活输出 MSE 的局部损失。这样只需逐层优化局部损失，即可完成对量化误差的优化。

AdaRound 算法#

为了对舍入方向进行优化，AdaRound 设计了一种对上述局部损失的优化方法。AdaRound 的目标函数为当前层预激活 MSE 加入了一个正则化项。正则化项的参数 V\mathbf{V}V 是与参数 W\mathbf{W}W 同维度的可学习参数，用来控制量化误差的舍入方向。AdaRound 的目标函数可以表示为：

arg⁡min⁡ΔW(ℓ) ∥Wx−W~x∥F2+λfreg(V),\underset{\Delta \mathbf{W}^{(\ell)}}{\arg\min} \space \| \mathbf{W}\mathbf{x} - \widetilde{\mathbf{W}}\mathbf{x} \| _{F} ^{2} + \lambda f _{reg}(\mathbf{V}),ΔW(ℓ)argmin ∥Wx−Wx∥F2+λfreg(V),

其中 W~\widetilde{\mathbf{W}}W 是经过量化的权重参数：

W~=s⋅clip(⌊Ws⌋+h(V),n,p).\widetilde{\mathbf{W}} = s \cdot \text{clip} \left( \left\lfloor \frac{\mathbf{W}}{s} \right\rfloor + h(\mathbf{V}),n,p \right).W=s⋅clip(⌊sW⌋+h(V),n,p).

与常规的对称线性量化函数不同，AdaRound 的量化函数将就近舍入改为向下取整后加上一个整流函数 hhh：

h(Vi,j)=clip(σ(Vi,j)(ζ−γ)+γ,0,1),h(\mathbf{V} _{i,j}) = \text{clip} \left( \sigma(\mathbf{V} _{i,j})(\zeta - \gamma) + \gamma, 0, 1 \right),h(Vi,j)=clip(σ(Vi,j)(ζ−γ)+γ,0,1),

整流函数 hhh 的输入为 V\mathbf{V}V，输出为普通 Sigmoid 函数 σ\sigmaσ 经过范围缩放后再进行截断至范围 [0,1][0,1][0,1] 之间的结果，表示当前参数的自适应舍入方向。这样设计的目的是为了避免 Sigmoid 函数在趋近 000 或 111 时的梯度消失问题。其中，缩放系数 ζ\zetaζ 和 γ\gammaγ 分别设定为 ζ=1.1\zeta=1.1ζ=1.1 和 γ=−0.1\gamma=-0.1γ=−0.1。

freg(V)=∑i,j1−∣2h(Vi,j)−1∣β,f _{reg} (\mathbf{V}) = \sum _{i,j} 1 - | 2h(\mathbf{V} _{i,j}) - 1 | ^{\beta},freg(V)=i,j∑1−∣2h(Vi,j)−1∣β,

AdaRound 目标函数的正则项 fregf _{reg}freg 使用退火温度参数 β\betaβ 来指导可学习参数 V\mathbf{V}V 的收敛。温度参数 β\betaβ 的值初始化为较大的数值，在初始阶段加大惩罚力度帮助 V\mathbf{V}V 收敛。之后在优化过程中逐渐减小，进一步优化预激活 MSE。考虑到神经网络中量化误差会逐层累加，上述优化过程也是逐层进行。为了避免累加的量化误差对最终模型精度的影响，在逐层优化的过程中，当前被量化层的输入是之前所有层经过量化后得到的输出。除此之外，激活函数对量化的影响也需要被考虑到优化范围内。这样就得到了 AdaRound 最终的优化目标函数。

arg⁡min⁡V ∥fa(Wx)−fa(W~x^)∥F2+λfreg(V),\underset{\mathbf{V}}{\arg\min} \space \left\| f _{a}(\mathbf{W} \mathbf{x}) - f _{a}(\widetilde{\mathbf{W}} \hat{\mathbf{x}}) \right\| _{F} ^{2} + \lambda f _{reg} (\mathbf{V}),Vargmin fa(Wx)−fa(Wx^)F2+λfreg(V),

实验#

消融实验#

本文从以下五个方面展开了消融实验，验证本文所提出方法的有效性。 从全局损失到局部损失目标函数的选择。本文对比了原始的就近舍入量化、Hessian 矩阵二次型、预激活 MSE 以及 AdaRound 目标函数的模型参数重建量化效果，结果表明，使用 AdaRound 的目标函数进行优化的量化效果最优。

表 1 不同局部损失目标函数的对比实验

AdaRound 整流函数 hhh 的选择。本文对比了使用退火参数的 Sigmoid 函数、普通 Sigmoid 函数加正则项函数以及整流函数 hhh 加正则化项三种情况，结果表明，使用整流函数 hhh 加正则化项能够在网络整体的量化上达到更好的效果。

表 2 不同整流函数 h 的对比实验

使用 STE 进行优化。本文对比了使用辅助变量进行优化重建的方法以及使用直通估计器（Straight Through Estimator，STE）进行量化感知训练的方法。结果表明，使用重建的方法要比使用 STE 的 QAT 方法效果要更好一些，原因是 STE 可能会导致量化前后的参数反向传播时梯度不匹配（Gradient Mismatch）问题。

表 3 是否使用 STE 进行微调的对比实验

优化参数缩放系数的指标。AdaRound 仍然沿用原始的对称线性量化函数，因此在进行重建前需要提前优化确定参数的缩放系数 sss，一般采用网格搜索的方法来穷举某一目标函数的值，取某种指标的最优值点来确定缩放系数。本文对比了最大最小值差、权重参数 MSE 和激活 MSE 三种指标函数，结果表明，使用权重 MSE 或激活 MSE 对 AdaRound 初始化都能获得较优的量化效果。

表 4 使用不同优化参数缩放系数指标初始化的对比实验

校准集样本量大小。本文对校准集的大小对量化的影响进行了探究。结果表明，校准集样本数量越大，量化导致的模型预测损失越低。另外，AdaRound 对校准集的采样来源具有较高的鲁棒性，使用不同任务的数据集作为校准集只会有很微小的精度下降。

图 6 不同校准集样本量大小情况下的对比实验

对比实验#

AdaRound 主要对比了 2020 年以前在 ImageNet 图像分类任务上对经典卷积神经网络模型的各种量化方法。结果如下：

表 5 AdaRound 在 ImageNet 图像分类任务的各模型上的对比实验结果

总结#

本文提出了 AdaRound，一种对舍入进行优化的后训练量化方法。同样是对网络的权重参数做优化，不同于过去使用深度学习常用的基于全局损失的梯度下降的优化方式，这种方法采用经过特殊设计的优化目标函数来对一部分可学习参数做微调。这种优化方法也被称为基于重建（Reconstruction）的量化方法。TSQ⁵、AdaQuant⁶、Bit Split⁷ 等针对模型量化的研究也使用了类似的基于重建的量化方法。相比传统的线性量化方法，AdaRound 在最终量化模型的推理精度上有着明显的提升。 Qualcomm AI 研究院将 AdaRound 方法用在了其全新推出的深度学习模型部署框架 AIMET⁸ 中作为核心后训练量化算法，推进了深度模型的轻量化发展与实际场景的应用。

BRECQ#

论文信息

Title: BRECQ: Pushing the Limit of Post-Training Quantization by Block Reconstruction
Venue: ICLR 2021
Author(s): Yuhang Li, Ruihao Gong, Xu Tan, Yang Yang, Peng Hu, Qi Zhang, Fengwei Yu, Wei Wang, Shi Gu
Institution(s): UESTC, SenseTime Research
Link: arXiv:2102.05426

前言#

AdaRound 为后训练量化算法指明了一个很好的方向：利用包含 Hessian 矩阵的二次型来近似量化的全局损失函数。然而，AdaRound 优化方法仍然存在一些局限性：AdaRound 采用层级的量化粒度，忽略了不同层参数之间的相关性，这样会导致在极低比特量化下模型推理精度大幅下降；另外，AdaRound 在将全局损失转化为局部损失时基于两个强假设，忽略了同一层内不同参数的部分相关性，这样实际会损失过多有价值的信息。为了摆脱这些局限性，以获得更好的量化效果，本文在 AdaRound 的基础上提出了新的基于块级重建（Block-wise Reconstruction）的优化方法 BRECQ，对上面提到的问题进行了针对性的改进。

方法#

不同层间参数的相关性#

神经网络的后训练量化一般选择层级的量化粒度，即网络中的每一个参数化层分别对应一个量化映射，这直观上与深度神经网络层级堆叠的设计结构相吻合，但是却忽略了层级之间的参数的相关性。层级量化本质上是对量化这一全局优化问题的简化，显然，神经网络作为一个优化的整体，层级之间参数的相关性必然会对量化效果产生影响。此时仍可以借助 Hessian 矩阵来探究层级之间参数的相关性。记神经网络的预激活 z(n)=f(θ)\mathbf{z} ^{(n)} = f(\theta)z(n)=f(θ)，任务损失函数为 L(f(θ))L(f(\theta))L(f(θ))，其中 θ\thetaθ 为网络的参数。则损失函数对网络中任意参数的二阶偏导数可以表示为：

∂2L∂θi∂θj=∂∂θj(∑k=1m∂L∂zk(n)∂zk(n)∂θi)=∑k=1m∂L∂zk(n)∂2zk(n)∂θi∂θj+∑k,l=1m∂zk(n)∂θi∂2L∂zk(n)∂zl(n)∂zl(n)∂θj,\frac{\partial^{2} L}{\partial \theta _{i} \partial \theta _{j}} = \frac{\partial}{\partial \theta _{j}} \left( \sum _{k=1} ^{m} \frac{\partial L}{\partial \mathbf{z} _{k}^ {(n)}} \frac{\partial \mathbf{z} _{k} ^{(n)}}{\partial \theta _{i}} \right) = \sum _{k=1} ^{m} \frac{\partial L}{\partial \mathbf{z} _{k} ^{(n)}} \frac{\partial ^{2} \mathbf{z} _{k} ^{(n)}}{\partial \theta _{i} \partial \theta _{j}} + \sum _{k,l=1} ^{m} \frac{\partial \mathbf{z} _{k} ^{(n)}}{\partial \theta _{i}} \frac{\partial ^{2} L}{\partial \mathbf{z} _{k} ^{(n)} \partial \mathbf{z} _{l} ^{(n)}} \frac{\partial \mathbf{z} _{l} ^{(n)}}{\partial \theta _{j}},∂θi∂θj∂2L=∂θj∂(k=1∑m∂zk(n)∂L∂θi∂zk(n))=k=1∑m∂zk(n)∂L∂θi∂θj∂2zk(n)+k,l=1∑m∂θi∂zk(n)∂zk(n)∂zl(n)∂2L∂θj∂zl(n),

由于预训练模型的参数可以看作已经收敛，因此可以假设原任务损失 LLL 对 z\mathbf{z}z 的一阶偏导数近似为 000，那么，损失函数对任意一组参数的 Hessian 矩阵可以进一步简化为以下的 Gauss-Newton 矩阵形式：

H(θ)≈G(θ)=Jz(n)(θ)THz(n)Jz(n)(θ),\mathbf{H} ^{(\theta)} \approx \mathbf{G} ^{(\theta)} = \mathbf{J} _{\mathbf{z} ^{(n)}} \left( \theta \right) ^{\text{T}} \mathbf{H} ^{\mathbf{z} ^ {(n)}} \mathbf{J} _{\mathbf{z} ^{(n)}} \left( \theta \right),H(θ)≈G(θ)=Jz(n)(θ)THz(n)Jz(n)(θ),

其中 Jz(n)(θ)\mathbf{J} _{\mathbf{z} ^{(n)}} (\theta)Jz(n)(θ) 是预激活 z\mathbf{z}z 对网络参数 θ\thetaθ 的 Jacobi 矩阵，Hz(n)\mathbf{H} ^{\mathbf{z} ^ {(n)}}Hz(n) 是预激活 z\mathbf{z}z 对任务损失 LLL 的 Hessian 矩阵。这两个矩阵的规模都很大，因此需要对其进行简化。

简化 Jacobi 矩阵 J\mathbf{J}J。考虑量化对网络层输出的扰动 Δz(n)\Delta \mathbf{z} ^{(n)}Δz(n)，Jacobi 矩阵 J\mathbf{J}J 可以看作对 Δz(n)\Delta \mathbf{z} ^{(n)}Δz(n) 进行一阶泰勒展开后的一阶偏导项：

Δz(n)=z^(n)−z(n)≈Jz(n)(θ)Δθ.\Delta \mathbf{z} ^{(n)} = \hat{\mathbf{z}} ^{(n)} - \mathbf{z} ^{(n)} \approx \mathbf{J} _{\mathbf{z} ^{(n)}} (\theta) \Delta \theta.Δz(n)=z^(n)−z(n)≈Jz(n)(θ)Δθ.

考虑原量化问题的目标函数，即：

arg⁡min⁡Δθ ΔθTHˉ(θ)Δθ\begin{align*} \underset{\Delta \theta}{\arg\min} \space \Delta \theta ^{\text{T}} \bar{\mathbf{H}} ^{(\theta)} \Delta \theta \end{align*}Δθargmin ΔθTHˉ(θ)Δθ

将 Jacobi 矩阵 J\mathbf{J}J 用泰勒展开的近似式代入，可得简化的量化目标函数：

arg⁡min⁡θ^ ΔθTHˉ(θ)Δθ≈arg⁡min⁡θ^ E[Δz(n),THz(n)Δz(n)].\begin{align*} \underset{\hat{\theta}}{\arg\min} \space \Delta \theta ^{\text{T}} \bar{\mathbf{H}} ^{(\theta)} \Delta \theta \approx \underset{\hat{\theta}}{\arg\min} \space \mathbb{E} \left[ \Delta \mathbf{z} ^{(n),\text{T}} \mathbf{H} ^{\mathbf{z} ^ {(n)}} \Delta \mathbf{z} ^{(n)} \right]. \end{align*}θ^argmin ΔθTHˉ(θ)Δθ≈θ^argmin E[Δz(n),THz(n)Δz(n)].

简化 Hessian 矩阵 H\mathbf{H}H。本文提出使用 Fisher 信息矩阵（Fisher Information Matrix，FIM）来近似预激活 z\mathbf{z}z 对网络参数 θ\thetaθ 的 Hessian 矩阵。
给定一个概率模型 p(x∣θ)p(x|\theta)p(x∣θ)，使用已知的观测样本通过极大似然估计（Maximum Likelihood Estimate）对参数 θθθ 进行优化，使得观测样本出现概率取极大值。相当于使评分函数 s(θ)s(θ)s(θ)，即对数似然函数对参数 θθθ 的一阶偏导数趋近 000。Fisher 信息定义为该一阶偏导数的二阶矩，在一般情况下，对数似然函数对参数 θθθ 的一阶偏导数的期望为 000，因此 Fisher 信息也可以表示为概率模型对参数极大似然估计的评分函数 sss 的方差。对于所有参数 θθθ，FIM 表示如下：

Fˉ(θ)=E[∇θlog⁡pθ(y∣x)∇θlog⁡pθ(y∣x)T]=−E[∇θ2log⁡pθ(y∣x)]=−Hˉlog⁡p(x∣θ)(θ).\bar{\mathbf{F}} ^{(\theta)} = \mathbb{E} \left[ \nabla _{\theta} \log p _{\theta} (y|x) \nabla _{\theta} \log p _{\theta} (y|x) ^{\text{T}} \right] = - \mathbb{E} \left[ \nabla _{\theta} ^{2} \log p _{\theta} (y|x) \right] = -\bar{\mathbf{H}} _{\log p(x|\theta)} ^{(\theta)}.Fˉ(θ)=E[∇θlogpθ(y∣x)∇θlogpθ(y∣x)T]=−E[∇θ2logpθ(y∣x)]=−Hˉlogp(x∣θ)(θ).

可以看出，FIM 也可以等价于概率模型的对数似然函数的 Hessian 矩阵的期望的负值。因此，在二阶优化方法中，FIM 一般可以作为 Hessian 矩阵的近似替代。深度神经网络模型的优化方法与概率模型的极大似然估计方法类似，如果能够尽量保证训练样本的分布尽量接近真实数据分布，并且预训练模型参数已经在训练集上收敛，那么就可以使用 FIM 来近似 Hessian 矩阵 H\mathbf{H}H。 Adam 优化器使用了参数梯度的二阶矩估计来为不同的参数设计独立的自适应学习率，在计算中使用梯度的平方，即 FIM 的对角元素。本文采用类似的思想，使用了 FIM 的对角元素组成的对角矩阵来替换 Hessian 矩阵。一个直观的解释是，梯度平方的值越大，该参数参与量化重建的重要性越高。替换后的优化目标函数变为：

min⁡w^ E[Δz(ℓ),TH(z(ℓ))Δz(ℓ)]=min⁡w^ E[Δz(ℓ),Tdiag(F(w))Δz(ℓ)].\underset{\hat{\mathbf{w}}}{\min} \space \mathbb{E} \left[ \Delta \mathbf{z} ^{(\ell), \text{T}} \mathbf{H} ^{(\mathbf{z} ^{(\ell)})} \Delta \mathbf{z} ^{(\ell)} \right] = \underset{\hat{\mathbf{w}}}{\min} \space \mathbb{E} \left[ \Delta \mathbf{z} ^{(\ell), \text{T}} \text{diag}(\mathbf{F} ^{(\mathbf{w})}) \Delta \mathbf{z} ^{(\ell)} \right].w^min E[Δz(ℓ),TH(z(ℓ))Δz(ℓ)]=w^min E[Δz(ℓ),Tdiag(F(w))Δz(ℓ)].

块级重建#

前面提到，基于层级的量化重建会损失不同层参数之间的相关性信息，因此需要探究合适的量化粒度来权衡量化优化问题的规模与层级间相关性损失。本文分析了四种不同的量化重建粒度，从大到小依次为整网（Network-wise）重建、阶段（Stage-wise）重建、块级（Block-wise）重建和层级（Layer-wise）重建，不同粒度的规模如图 7 所示。

图 7 深度神经网络的不同粒度示意图

不同的重建粒度，其 Hessian 矩阵的规模也不同。如图 8 所示，块级或层级的 Hessian 矩阵相当于整网参数的 Hessian 矩阵的分块对角矩阵。

图 8 不同粒度的 Hessian 矩阵规模示意图

本文对上述四种不同量化粒度的参数重建进行了实验，发现使用块级重建粒度的量化效果最优。使用块级重建的优越性可以从两方面解释。第一，ResNet 等网络采用的残差连接（Residual Connection）可能会加强块级参数的相关性；第二，校准集一般规模较小，比起粒度更大的阶段或整网重建，块级粒度的参数重建更不容易发生过拟合现象。本文将这种基于块级重建的量化方法称为 BRECQ。

实验#

消融实验#

本文对上面提到的四种不同的重建粒度进行了消融实验。在 ImageNet 图像分类任务上对 ResNet-18 和 MobileNet-V2 模型进行 2-bit 量化，结果见表 6。结果表明，块级重建的量化效果要比其它粒度的效果要好。

表 6 不同重建粒度的消融实验

对比实验#

本文在 ImageNet 图像分类任务和 MS COCO 目标检测任务上展开工作。在 ImageNet 图像分类任务上的对比结果如下：

表 7 BRECQ 在 ImageNet 图像分类任务上的各模型的对比实验结果

在 MS COCO 目标检测任务上的对比结果如下：

表 8 BRECQ 在 MS COCO 目标检测任务上的各模型的对比实验结果

总结#

本文提出了 BRECQ，一种由 AdaRound 改进而来的基于块级重建的后训练量化方法。BRECQ 设计了新的优化目标函数，充分考虑了块内参数之间的相关性，弥补了层级重建中层级间的参数相关性的损失。BRECQ 的量化效果要显著优于 AdaRound 以及其它的基于重建的量化方法。商汤科技模型部署与工具链团队将 BRECQ 方法作为后训练量化算法的示例整合到了他们推出的开源模型量化框架 MQBench⁹ 中。

ModelTC

MQBench

Waiting for api.github.com...

00K

Waiting...

QDrop#

论文信息

Title: QDrop: Randomly Dropping Quantization for Extremely Low-bit Post-Training Quantization
Venue: ICLR 2022
Author(s): Xiuying Wei, Ruihao Gong, Yuhang Li, Xianglong Liu, Fengwei Yu
Institution(s): Beihang University, SenseTime Research
Link: arXiv:2203.05740

前言#

常规的 PTQ 方法对网络权重和激活的量化是相互独立的，一般的流程是先量化权重值，再量化激活值。AdaRound 和 BRECQ 方法与传统 PTQ 方法类似，它们都是先对网络权重参数进行重建，然后使用传统方法对激活值进行量化。这种 PTQ 流程忽略了激活量化对权重量化的影响，依然存在改进空间。本文提出的 QDrop 在 BRECQ 的基础上进行了改进，将对网络权重的重建和对激活量化的优化结合在一起，充分考虑到了整体的量化损失。QDrop 的量化效果在量化不友好的网络（例如 MobileNet-V2）上显著超越了之前的方法。

方法#

激活量化如何影响权重量化#

为了验证激活量化对权重参数重建的影响，本文首先基于 BRECQ 方法针对三种不同的激活量化策略开展了对比实验进行观察，三种激活量化策略如下，示意图和结果如图 9 所示。

Case 1：原始的 BRECQ 方法。重建时不对激活进行量化；
Case 2：对当前重建的块以及之前的所有重建完毕的块的激活进行量化。
Case 3：对当前重建的块之前的所有重建完毕的块的激活进行量化，不对当前块的激活进行量化。

图 9 三种激活量化策略示意图及量化结果

实验表明，Case 3 的量化效果最好。也就是说，如果在参数重建的过程中对部分块进行激活量化，有可能提高量化效果。
类似于之前对权重量化的数学定义，对激活的量化也可以定义为对其的扰动，记为 e=(a^−a)e=(\hat{a} - a)e=(a^−a)。本文将该扰动由减法形式转化为乘法形式，即 a^=a⋅(1+u)\hat{a} = a \cdot (1+u)a^=a⋅(1+u)。定义同时对权重和激活的量化扰动的全局损失为 L(w+Δw,x,1+u(x))L(\boldsymbol{w} + \Delta \boldsymbol{w}, \boldsymbol{x}, \mathbf{1} + \boldsymbol{u}(\boldsymbol{x}))L(w+Δw,x,1+u(x))，那么量化要优化的目标函数为：

min⁡w^Ex∼Dc[L(w+Δw,x,1+u(x))−L(w,x,1)].\min _{\hat{\boldsymbol{w}}} \mathbb{E} _{\boldsymbol{x}\sim\mathcal{D} _{c}} [L(\boldsymbol{w} + \Delta \boldsymbol{w}, \boldsymbol{x}, \boldsymbol{1} + \boldsymbol{u}(\boldsymbol{x})) - L(\boldsymbol{w}, \boldsymbol{x}, \boldsymbol{1})].w^minEx∼Dc[L(w+Δw,x,1+u(x))−L(w,x,1)].

卷积、全连接等线性变换层的运算均可以用矩阵乘法 y=Wa\boldsymbol{y}=\boldsymbol{W}\boldsymbol{a}y=Wa 来表示。对激活 a\boldsymbol{a}a 加入的扰动 u(x)\boldsymbol{u}(\boldsymbol{x})u(x) ，可以传递到对权重 W\boldsymbol{W}W 上：

W(a⊙[1+u1(x)1+u2(x)...1+un(x)])=(W⊙[1+u1(x)1+u2(x)...1+un(x)1+u1(x)1+u2(x)...1+un(x)...1+u1(x)1+u2(x)...1+un(x)])a.\boldsymbol{W}(\boldsymbol{a} \odot \begin{bmatrix} 1 + \boldsymbol{u} _{1}(\boldsymbol{x}) \\\\ 1 + \boldsymbol{u} _{2}(\boldsymbol{x}) \\\\ ... \\\\ 1 + \boldsymbol{u} _{n}(\boldsymbol{x}) \end{bmatrix}) = (\boldsymbol{W} \odot \begin{bmatrix} 1 + \boldsymbol{u} _{1}(\boldsymbol{x}) & 1 + \boldsymbol{u} _{2} (\boldsymbol{x}) & ... & 1 + \boldsymbol{u} _{n}(\boldsymbol{x}) \\\\ 1 + \boldsymbol{u} _{1}(\boldsymbol{x}) & 1 + \boldsymbol{u} _{2} (\boldsymbol{x}) & ... & 1 + \boldsymbol{u} _{n}(\boldsymbol{x}) \\\\ ... \\\\ 1 + \boldsymbol{u} _{1}(\boldsymbol{x}) & 1 + \boldsymbol{u} _{2} (\boldsymbol{x}) & ... & 1 + \boldsymbol{u} _{n}(\boldsymbol{x}) \end{bmatrix}) \boldsymbol{a}.W(a⊙1+u1(x)1+u2(x)...1+un(x))=(W⊙1+u1(x)1+u1(x)...1+u1(x)1+u2(x)1+u2(x)1+u2(x).........1+un(x)1+un(x)1+un(x))a.

目标函数可以进一步转化为：

Ex∼Dc[L(w^,x,1+u(x))−L(w,x,1)]≈Ex∼Dc[L(w^⊙(1+v(x)),x,1)−L(w,x,1)],\mathbb{E} _{\boldsymbol{x}\sim\mathcal{D} _{c}} [L (\hat{\boldsymbol{w}}, \boldsymbol{x}, \mathbf{1} + \boldsymbol{u}(\boldsymbol{x})) - L(\boldsymbol{w}, \boldsymbol{x}, \boldsymbol{1})] \approx \mathbb{E} _{\boldsymbol{x}\sim\mathcal{D} _{c}} [L(\hat{\boldsymbol{w}} \odot(\mathbf{1} + \boldsymbol{v}(\boldsymbol{x})), \boldsymbol{x}, \boldsymbol{1}) - L(\boldsymbol{w}, \boldsymbol{x}, \boldsymbol{1})],Ex∼Dc[L(w^,x,1+u(x))−L(w,x,1)]≈Ex∼Dc[L(w^⊙(1+v(x)),x,1)−L(w,x,1)],Ex∼Dc[L(w^,x,1+u(x))−L(w,x,1)]≈Ex∼Dc[(L(w^,x,1)−L(w,x,1))⏟(7−1)+(L(w^⊙(1+v(x)),x,1)−L(w^,x,1))⏟(7−2)]\begin{align*} \mathbb{E} _{\boldsymbol{x} \sim \mathcal{D} _{c}} [L(\hat{\boldsymbol{w}}, \boldsymbol{x}, \boldsymbol{1} + \boldsymbol{u}(\boldsymbol{x})) - L(\boldsymbol{w}, \boldsymbol{x}, \boldsymbol{1})] &\approx \\\\ \mathbb{E} _{\boldsymbol{x} \sim \mathcal{D} _{c}} [\underbrace{(L(\hat{\boldsymbol{w}}, \boldsymbol{x}, \boldsymbol{1}) - L(\boldsymbol{w},\boldsymbol{x}, \boldsymbol{1}))} _{(7-1)} &+ \underbrace{(L(\hat{\boldsymbol{w}} \odot (\boldsymbol{1} + \boldsymbol{v}(\boldsymbol{x})), \boldsymbol{x}, \boldsymbol{1}) - L(\hat{\boldsymbol{w}}, \boldsymbol{x}, \boldsymbol{1}))} _{(7-2)}] \end{align*}Ex∼Dc[L(w^,x,1+u(x))−L(w,x,1)]Ex∼Dc[(7−1)(L(w^,x,1)−L(w,x,1))≈+(7−2)(L(w^⊙(1+v(x)),x,1)−L(w^,x,1))]

上式的第一项为权重参数重建的损失，第二项为参数重建后的网络再加入激活量化之后的损失。也就是说，通过乘法项引入的对激活的量化扰动，对整体的量化损失是有影响的。
可以从量化扰动鲁棒性的角度来理解由激活引入的第二项损失。对激活的量化可以看作对参数重建后的量化网络加入的噪声。如果在输入加入了噪声的情况下进行优化，网络参数优化时的损失平面理论上会更加平坦，即鲁棒性更强。这也解释了前面对比实验中 Case 2 和 Case 3 比第一种情况的效果更好的原因。

QDrop#

本文提出了一种权重和激活量化相结合的参数重建优化方案，命名为 QDrop。QDrop 是从前文所述的对比实验的第三种情况加以改进得到的。与原先不同的是，QDrop 对当前重建的层也加入了对输入激活的量化，但是只会以一定的概率 ppp 来决定输入的每一个元素是否不进行量化，类似于深度学习中的 Dropout，即：

QDROP:u={0with probability pa^a−1with probability 1−p.\mathrm{QDROP}:u= \begin{cases} 0 & \text{with probability }p \\\\ \frac{\hat{a}}{a}-1 & \text{with probability }1-p \end{cases}.QDROP:u=⎩⎨⎧0aa^−1with probability pwith probability 1−p.

使用 QDrop 得到的参数优化损失平面与其它情况的对比如图 10 所示。可以看到，使用 QDrop 方法的损失平面要比之前更加平坦。

图 10 Case 1、Case 3 和 QDrop 的参数损失平面对比

实验#

消融实验#

QDrop 与 No Drop。本文对比了使用 QDrop 方法进行随机地激活量化和完全进行激活量化的效果。结果如表 9 所示。结果表明使用 QDrop 后预测精度有所提升。

表 9 QDrop 与 No Drop 消融实验结果

QDrop 概率 ppp 的选择。本文对 QDrop 概率 ppp 的选择进行了消融实验，结果如图 11 所示。结果表明，QDrop 概率 ppp 的值对量化效果有较大影响，过小或过大的概率都会导致量化效果下降。可以看出，当 p=0.5p=0.5p=0.5 时量化模型的预测精度最高。但对于更细粒度的搜索空间本文未作过多讨论。

图 11 不同概率 p 下 QDrop 实验结果

对比实验#

QDrop 在 ImageNet 图像分类任务、MS COCO 目标检测任务和各个自然语言处理任务上展开工作。在 ImageNet 图像分类任务上的对比结果如下：

表 10 QDrop 在 ImageNet 图像分类任务上的各模型的对比实验结果

在 MS COCO 目标检测任务上的对比结果如下：

表 11 QDrop 在 MS COCO 目标检测任务上的各模型的对比实验结果

在各个自然语言处理任务上的对比结果如下：

表 12 QDrop 在各个 NLP 任务上的各模型的对比实验结果

总结#

本文提出了 QDrop，一种由 BRECQ 改进而来的基于块级重建的后训练量化方法。基于重建的优化方法相比过去的 PTQ 方法的一个优势在于，激活量化和权重量化可以同时进行。QDrop 将对激活的量化与对权重的重建结合到了一起，充分考虑了量化任务对网络模型的整体影响，最终的量化效果达到了 PTQ 方法的新极限。
商汤科技模型部署与工具链团队在 ICLR 2022 发表相关研究论文之后，将 QDrop 方法作为后训练量化算法的示例整合到了他们推出的开源模型量化框架 MQBench⁹ 中，并将在之后陆续支持对 NLP 相关任务的网络模型的量化。

参考文献#

Footnotes#

How to Break MD5 and Other Hash Functions

Sat, 04 Dec 2021 00:00:00 GMT

阅读说明

个人论文阅读报告留档：总结发表于 EUROCRYPT 2005 的论文 How to Break MD5 and Other Hash Functions，介绍基于模差的 MD5 碰撞攻击、充分条件与信息修改技术，并简述对 MD4 等函数的适用性。

论文信息

Title: How to Break MD5 and Other Hash Functions
Venue: EUROCRYPT 2005
Author(s): Xiaoyun Wang, Hongbo Yu
Institution(s): Shandong University
Link: Springer PDF

引言#

MD5（Message Digest 5）由 Ron Rivest 于 1992 年提出，是对 MD4 的加强。作为长期广泛使用的密码哈希函数之一，其安全性一直受到关注。此前较著名的结果多为伪碰撞或 semi-free-start collision（将标准初值换成非标准初值）。Wang & Yu¹ 提出一种真正的两块消息碰撞攻击：以模整数减法（而非异或）度量差分，称为模差（modular differential）。在 IBM P690 上，找第一块消息对大约需 15 分钟到 1 小时；第二块约 15 秒到 5 分钟。同一思路也可用于 MD4、RIPEMD、HAVAL 等。

数字签名、完整性校验、群签名、电子现金等应用都依赖底层哈希的抗碰撞能力。当时国际通用哈希以 MD5 与 SHA-1 为代表。1993 年，Den Boer 与 Bosselaers 给出伪碰撞（相同消息、不同初值），暴露了链接变量最高位的弱雪崩。Eurocrypt’96 Rump Session 上，Dobbertin 给出 semi-free-start collision，所用非标准初值为：

a0=0x12ac2375,b0=0x3b341042,c0=0x5f62b97c,d0=0x4ba763eda_0=\texttt{0x12ac2375},\quad b_0=\texttt{0x3b341042},\quad c_0=\texttt{0x5f62b97c},\quad d_0=\texttt{0x4ba763ed}a0=0x12ac2375,b0=0x3b341042,c0=0x5f62b97c,d0=0x4ba763ed

虽未得到标准初值下的真碰撞，但说明在一次压缩中构造特殊差分是可能的。受此启发，本文关心：能否找到由两块组成的消息对 (M0,M1)(M_0,M_1)(M0,M1) 与 (M0′,M1′)(M_0',M_1')(M0′,M1′)，使第二块之后发生 MD5 碰撞，即

(a,b,c,d)=MD5(a0,b0,c0,d0,M0),(a′,b′,c′,d′)=MD5(a0,b0,c0,d0,M0′),MD5(a,b,c,d,M1)=MD5(a′,b′,c′,d′,M1′),\begin{aligned} (a,b,c,d)&=\mathrm{MD5}(a_0,b_0,c_0,d_0,M_0), \\ (a',b',c',d')&=\mathrm{MD5}(a_0,b_0,c_0,d_0,M_0'), \\ \mathrm{MD5}(a,b,c,d,M_1)&=\mathrm{MD5}(a',b',c',d',M_1'), \end{aligned}(a,b,c,d)(a′,b′,c′,d′)MD5(a,b,c,d,M1)=MD5(a0,b0,c0,d0,M0),=MD5(a0,b0,c0,d0,M0′),=MD5(a′,b′,c′,d′,M1′),

其中 a0,b0,c0,d0a_0,b_0,c_0,d_0a0,b0,c0,d0 为 MD5 标准初值。相对此前方法，找 (M0,M0′)(M_0,M_0')(M0,M0′) 约需 2292^{29}229 次 MD5 运算，找 (M1,M1′)(M_1,M_1')(M1,M1′) 约需 2322^{32}232 次（后文在计入信息修改开销时，也将第一块搜索复杂度表述为不超过 2392^{39}239）。所得碰撞实例（见表 2）曾在 Crypto’04 Rump Session 公布。同届会议上还有 Biham–Chen 对 SHA-0 的近碰撞、Joux 对 SHA-0 的四块完全碰撞等工作。

全文组织如下：MD5 算法简述 → 差分攻击思想 → MD5 上的差分攻击 → 总结，附录为原文表 1–6 截图。

MD5 算法简述#

哈希通常由压缩函数 X=f(Z)X=f(Z)X=f(Z) 迭代得到（Merkle–Damgård 结构）。压缩函数把长度为 lll 的消息块映射到长度为 sss 的摘要（l>sl>sl>s）。对 MD5，l=512l=512l=512，s=128s=128s=128。填充后长度为 512 比特倍数的消息 M=(M0,…,Mt−1)M=(M_0,\ldots,M_{t-1})M=(M0,…,Mt−1) 满足

Hi+1=f(Hi,Mi),0≤i≤t−1,H_{i+1}=f(H_i,M_i),\qquad 0\leq i\leq t-1,Hi+1=f(Hi,Mi),0≤i≤t−1,

初值 H0=IV0H_0=IV_0H0=IV0。本文攻击所用消息恰为两块（长度已是 512 的倍数），填充与否不影响结论。

每个 MiM_iMi 拆成 16 个 32 比特字 Mi=(m0,…,m15)M_i=(m_0,\ldots,m_{15})Mi=(m0,…,m15)。压缩函数分 4 个阶段（round），每阶段 16 步；连续四步形如

a=b+((a+ϕi(b,c,d)+wi+ti)⋘si),d=a+((d+ϕi+1(a,b,c)+wi+1+ti+1)⋘si+1),c=d+((c+ϕi+2(d,a,b)+wi+2+ti+2)⋘si+2),b=c+((b+ϕi+3(c,d,a)+wi+3+ti+3)⋘si+3),\begin{aligned} a&=b+\bigl((a+\phi_i(b,c,d)+w_i+t_i)\lll s_i\bigr), \\ d&=a+\bigl((d+\phi_{i+1}(a,b,c)+w_{i+1}+t_{i+1})\lll s_{i+1}\bigr), \\ c&=d+\bigl((c+\phi_{i+2}(d,a,b)+w_{i+2}+t_{i+2})\lll s_{i+2}\bigr), \\ b&=c+\bigl((b+\phi_{i+3}(c,d,a)+w_{i+3}+t_{i+3})\lll s_{i+3}\bigr), \end{aligned}adcb=b+((a+ϕi(b,c,d)+wi+ti)⋘si),=a+((d+ϕi+1(a,b,c)+wi+1+ti+1)⋘si+1),=d+((c+ϕi+2(d,a,b)+wi+2+ti+2)⋘si+2),=c+((b+ϕi+3(c,d,a)+wi+3+ti+3)⋘si+3),

其中 +++ 为模 2322^{32}232 加法，ti+jt_{i+j}ti+j、si+js_{i+j}si+j 为与步数相关的常数，wi+jw_{i+j}wi+j 为消息字，⋘\lll⋘ 表示循环左移。四阶段非线性函数分别为

ϕi(X,Y,Z)=(X∧Y)∨(¬X∧Z),0≤i≤15,ϕi(X,Y,Z)=(X∧Z)∨(Y∧¬Z),16≤i≤31,ϕi(X,Y,Z)=X⊕Y⊕Z,32≤i≤47,ϕi(X,Y,Z)=Y⊕(X∨¬Z),48≤i≤63.\begin{aligned} \phi_i(X,Y,Z)&=(X\land Y)\lor(\lnot X\land Z), & 0&\leq i\leq 15, \\ \phi_i(X,Y,Z)&=(X\land Z)\lor(Y\land\lnot Z), & 16&\leq i\leq 31, \\ \phi_i(X,Y,Z)&=X\oplus Y\oplus Z, & 32&\leq i\leq 47, \\ \phi_i(X,Y,Z)&=Y\oplus(X\lor\lnot Z), & 48&\leq i\leq 63. \end{aligned}ϕi(X,Y,Z)ϕi(X,Y,Z)ϕi(X,Y,Z)ϕi(X,Y,Z)=(X∧Y)∨(¬X∧Z),=(X∧Z)∨(Y∧¬Z),=X⊕Y⊕Z,=Y⊕(X∨¬Z),0163248≤i≤15,≤i≤31,≤i≤47,≤i≤63.

链接变量初值为

a=0x67452301,b=0xefcdab89,c=0x98badcfe,d=0x10325476.a=\texttt{0x67452301},\quad b=\texttt{0xefcdab89},\quad c=\texttt{0x98badcfe},\quad d=\texttt{0x10325476}.a=0x67452301,b=0xefcdab89,c=0x98badcfe,d=0x10325476.

记上一块输出为 Hi−1=(aa,bb,cc,dd)H_{i-1}=(aa,bb,cc,dd)Hi−1=(aa,bb,cc,dd)，经四阶段后再与 Hi−1H_{i-1}Hi−1 逐字相加，得到本块压缩输出 HiH_iHi。

差分攻击思想#

模差与异或差#

差分攻击是分析哈希与分组密码的重要手段；分组密码中常见以异或为差分。Biham 与 Shamir 对 DES 类算法的差分密码分析，考察明文对特定差分如何影响密文对差分。

本文采用基于整数模减法的精确差分，并结合模特征同时描述异或差与模差，以获得比单独使用任一度量更丰富的信息。

例如未知量 XXX 满足 X′−X=26X'-X=2^6X′−X=26 时，异或差可有多种情形：

仅第 7 位不同：异或为 0x00000040\texttt{0x00000040}0x00000040，X′X'X′ 与 XXX 该位为 111 与 000；
第 7 位向第 8 位借位：异或为 0x000000c0\texttt{0x000000c0}0x000000c0，两比特模式分别为 101010 与 010101；
继续向第 9 位借位：异或为 0x000001c0\texttt{0x000001c0}0x000001c0，模式为 100100100 与 011011011；
更长连续借位时，X′X'X′ 与 XXX 分别呈 1000…1000\ldots1000… 与 0111…0111\ldots0111…；
若模差为负，异或绝对值可相同，但 X′X'X′ 与 XXX 的比特模式对调。

表示上，常同时给出模 2322^{32}232 的整数差，以及带符号的比特位置序列：某位在 XXX 上为 000 则无符号，为 111 则标负号。例如模差 −26-2^6−26 可记为 [7,8,…,22,−23][7,8,\ldots,22,-23][7,8,…,22,−23]，表示从第 7 位借到第 23 位：XXX 的第 7–22 位为 000、第 23 位为 111，而 X′X'X′ 相反。更复杂的例子如 −1−26+223−227-1-2^6+2^{23}-2^{27}−1−26+223−227 对应一长串带符号位置。最高位（第 32 位）也可参与借位；借位后该位本身不再标负号。

相对此前对 SHA-0、MD4、RIPEMD 等的模差分析，本文攻击有以下特点：

消息仅两块（各 512 比特），两次迭代即可碰撞；
差分特征更精确，除差分外还约束具体比特取值；
给出保证差分成立的充分条件；
使用信息修改技术（message modification），显著提高碰撞概率。

哈希上的差分形式#

定义 ΔX=X′−X\Delta X=X'-XΔX=X′−X。对长度同为 512 倍数的 M=(M0,…,Mk−1)M=(M_0,\ldots,M_{k-1})M=(M0,…,Mk−1) 与 M′=(M0′,…,Mk−1′)M'=(M_0',\ldots,M_{k-1}')M′=(M0′,…,Mk−1′)，完全差分写作

ΔH0→(M0,M0′)ΔH1→(M1,M1′)⋯→(Mk−1,Mk−1′)ΔH,\Delta H_0 \xrightarrow{(M_0,M_0')} \Delta H_1 \xrightarrow{(M_1,M_1')} \cdots \xrightarrow{(M_{k-1},M_{k-1}')} \Delta H,ΔH0(M0,M0′)ΔH1(M1,M1′)⋯(Mk−1,Mk−1′)ΔH,

其中 ΔH0=0\Delta H_0=0ΔH0=0，ΔH\Delta HΔH 为输出差，ΔHi\Delta H_iΔHi 既是第 iii 次迭代输出差，也是下一次迭代初值差。若 ΔH=0\Delta H=0ΔH=0，则发生碰撞，相应差分称为碰撞差分。

MD5 每次迭代含 4 阶段、每阶段 16 步。第 iii 次迭代差分可展开为

ΔHi→P1ΔRi+1,1→P2ΔRi+1,2→P3ΔRi+1,3→P4ΔRi+1,4=ΔHi+1.\Delta H_i \xrightarrow{P_1} \Delta R_{i+1,1} \xrightarrow{P_2} \Delta R_{i+1,2} \xrightarrow{P_3} \Delta R_{i+1,3} \xrightarrow{P_4} \Delta R_{i+1,4}=\Delta H_{i+1}.ΔHiP1ΔRi+1,1P2ΔRi+1,2P3ΔRi+1,3P4ΔRi+1,4=ΔHi+1.

各阶段再拆成 16 步差分特征，概率满足

P≥∏j=14Pj,Pj≥∏t=116Pjt.P\geq\prod_{j=1}^{4}P_j,\qquad P_j\geq\prod_{t=1}^{16}P_{jt}.P≥j=1∏4Pj,Pj≥t=1∏16Pjt.

更优碰撞差分的选取思路#

借助信息修改，可粗略指导如何寻找更好的（碰撞）差分：

对任意块对 (Mi,Mi′)(M_i,M_i')(Mi,Mi′) 与第一阶段非零差分 ΔHi→ΔRi+1,1\Delta H_i\to\Delta R_{i+1,1}ΔHi→ΔRi+1,1，可修改 MiM_iMi 使 P1=1P_1=1P1=1；
多重信息修改还能在保持 P1=1P_1=1P1=1 的同时显著提高第二阶段概率。

因此宜选取能使后两阶段仍以较高概率成立的消息差分。

MD5 上的差分攻击#

记号#

M=(m0,…,m15)M=(m_0,\ldots,m_{15})M=(m0,…,m15)、M′=(m0′,…,m15′)M'=(m_0',\ldots,m_{15}')M′=(m0′,…,m15′) 为两块 512 比特消息；Δmi=mi′−mi\Delta m_i=m_i'-m_iΔmi=mi′−mi。
ai,bi,ci,dia_i,b_i,c_i,d_iai,bi,ci,di 分别表示第 4i−3,4i−2,4i−1,4i4i-3,4i-2,4i-1,4i4i−3,4i−2,4i−1,4i 步的输出（1≤i≤161\leq i\leq 161≤i≤16）；带撇号者为对应 M′M'M′ 的量。
ai,ja_{i,j}ai,j 等表示字的第 jjj 位（第 1 位为最低位，第 32 位为最高位）。
ϕi,j\phi_{i,j}ϕi,j 为第 iii 步非线性函数输出的第 jjj 位。
xi[j]x_i[j]xi[j]（xi[−j]x_i[-j]xi[−j]）表示仅将 xix_ixi 第 jjj 位由 0→10\to 10→1（或 1→01\to 01→0）后的取值；xxx 可为 a,b,c,d,ϕa,b,c,d,\phia,b,c,d,ϕ。
xi[±j1,…,±jl]x_i[\pm j_1,\ldots,\pm j_l]xi[±j1,…,±jl] 表示若干指定位同时翻转；+++ 可省略，表示 0→10\to 10→1，−-− 表示 1→01\to 01→0。

MD5 的碰撞差分#

在标准初值 IV0IV_0IV0 下，寻找两段各 1024 比特的消息对，使

ΔH0→(M0,M0′)ΔH1→(M1,M1′)ΔH=0,\Delta H_0 \xrightarrow{(M_0,M_0')} \Delta H_1 \xrightarrow{(M_1,M_1')} \Delta H=0,ΔH0(M0,M0′)ΔH1(M1,M1′)ΔH=0,

其中

ΔM0=(0,0,0,0,231,0,0,0,0,0,0,215,0,0,231,0),ΔM1=(0,0,0,0,231,0,0,0,0,0,0,−215,0,0,231,0),ΔH1=(231, 231+225, 231+225, 231+225).\begin{aligned} \Delta M_0&=(0,0,0,0,2^{31},0,0,0,0,0,0,2^{15},0,0,2^{31},0), \\ \Delta M_1&=(0,0,0,0,2^{31},0,0,0,0,0,0,-2^{15},0,0,2^{31},0), \\ \Delta H_1&=(2^{31},\,2^{31}+2^{25},\,2^{31}+2^{25},\,2^{31}+2^{25}). \end{aligned}ΔM0ΔM1ΔH1=(0,0,0,0,231,0,0,0,0,0,0,215,0,0,231,0),=(0,0,0,0,231,0,0,0,0,0,0,−215,0,0,231,0),=(231,231+225,231+225,231+225).

非零差分落在下标为 444、111111、141414 的字上（即第 5、12、15 个字，从 0 计数）。ΔH1=(Δa,Δb,Δc,Δd)\Delta H_1=(\Delta a,\Delta b,\Delta c,\Delta d)ΔH1=(Δa,Δb,Δc,Δd) 为第一块压缩后链接变量之差。ΔM0\Delta M_0ΔM0 需使第 3、4 阶段差分以较高概率成立；ΔM1\Delta M_1ΔM1 还须使输出差被 ΔH1\Delta H_1ΔH1 抵消。

完整差分特征见表 3 与表 5（列含义相同）。表 3 各列依次为：步数；M0M_0M0 上该步链接变量；该步消息字；循环左移位数；M0M_0M0 与 M0′M_0'M0′ 的消息字 / 链接变量差分；M0′M_0'M0′ 的链接变量。空白表示无差分；完全无差分的步省略。

充分条件（以第 8 步为例）#

下面以表 3 中第 8 步为例，说明如何导出保证差分特征成立的充分条件。该步差分形为

(Δc2,Δd2,Δa2,Δb1)⟶Δb2,(\Delta c_2,\Delta d_2,\Delta a_2,\Delta b_1)\longrightarrow\Delta b_2,(Δc2,Δd2,Δa2,Δb1)⟶Δb2,

且

b1′=b1,a2′=a2[7,…,22,−23],d2′=d2[−7,24,32],c2′=c2[7,8,9,10,11,−12,−24,−25,−26,27,28,29,30,31,32,1,2,3,4,5,−6],b2′=b2[1,16,−17,18,19,20,−21,−24].\begin{aligned} b_1'&=b_1, \\ a_2'&=a_2[7,\ldots,22,-23], \\ d_2'&=d_2[-7,24,32], \\ c_2'&=c_2[7,8,9,10,11,-12,-24,-25,-26,27,28,29,30,31,32,1,2,3,4,5,-6], \\ b_2'&=b_2[1,16,-17,18,19,20,-21,-24]. \end{aligned}b1′a2′d2′c2′b2′=b1,=a2[7,…,22,−23],=d2[−7,24,32],=c2[7,8,9,10,11,−12,−24,−25,−26,27,28,29,30,31,32,1,2,3,4,5,−6],=b2[1,16,−17,18,19,20,−21,−24].

由压缩函数，

b2=c2+((b1+F(c2,d2,a2)+m7+t7)⋘22),b2′=c2′+((b1+F(c2′,d2′,a2′)+m7′+t7)⋘22),ϕ7=F(c2,d2,a2)=(c2∧d2)∨(¬c2∧a2).\begin{aligned} b_2&=c_2+\bigl((b_1+F(c_2,d_2,a_2)+m_7+t_7)\lll 22\bigr), \\ b_2'&=c_2'+\bigl((b_1+F(c_2',d_2',a_2')+m_7'+t_7)\lll 22\bigr), \\ \phi_7&=F(c_2,d_2,a_2)=(c_2\land d_2)\lor(\lnot c_2\land a_2). \end{aligned}b2b2′ϕ7=c2+((b1+F(c2,d2,a2)+m7+t7)⋘22),=c2′+((b1+F(c2′,d2′,a2′)+m7′+t7)⋘22),=F(c2,d2,a2)=(c2∧d2)∨(¬c2∧a2).

为区分右端两次出现的 c2c_2c2，记 c2Fc_2^Fc2F 为 FFF 内的 c2c_2c2，c2NFc_2^{NF}c2NF 为 FFF 外的 c2c_2c2。推导基于：

Δb1=0\Delta b_1=0Δb1=0 且 Δm7=0\Delta m_7=0Δm7=0 时，Δb2=Δc2NF+(Δϕ7⋘22)\Delta b_2=\Delta c_2^{NF}+(\Delta\phi_7\lll 22)Δb2=Δc2NF+(Δϕ7⋘22)；
固定 FFF 的一个或两个自变量后，FFF 可退化为单变量函数。

据此可列出使差分保持的充分条件。对 Δb2\Delta b_2Δb2 的非零位：

(a) d2,11=1d_{2,11}=1d2,11=1、b2,1=0b_{2,1}=0b2,1=0 时，可保证 b2b_2b2 第 1 位翻转。若再有 d2,11=a2,11‾=1d_{2,11}=\overline{a_{2,11}}=1d2,11=a2,11=1，则 Δϕ7,11=1\Delta\phi_{7,11}=1Δϕ7,11=1；左移 22 位后该差落在第 1 位；又 Δc2,1NF=0\Delta c_{2,1}^{NF}=0Δc2,1NF=0，故 Δb2,1=1\Delta b_{2,1}=1Δb2,1=1。
(b) d2,26=a2,26‾=1d_{2,26}=\overline{a_{2,26}}=1d2,26=a2,26=1、b2,16=0b_{2,16}=0b2,16=0 且 b2,17=1b_{2,17}=1b2,17=1 时，可保证第 16、17 位翻转。
(c) d2,28=a2,28‾=0d_{2,28}=\overline{a_{2,28}}=0d2,28=a2,28=0，b2,i=0b_{2,i}=0b2,i=0（i=18,19,20i=18,19,20i=18,19,20）且 b2,21=1b_{2,21}=1b2,21=1 时，可保证第 18–21 位翻转。
(d) d2,3=a2,3‾=0d_{2,3}=\overline{a_{2,3}}=0d2,3=a2,3=0、b2,24=1b_{2,24}=1b2,24=1 时，可保证第 24 位翻转，并有

Δc2NF[−24,−25,−26,27]+(Δϕ7[3]⋘22)=223−224=−223.\Delta c_2^{NF}[-24,-25,-26,27]+(\Delta\phi_7[3]\lll 22)=2^{23}-2^{24}=-2^{23}.Δc2NF[−24,−25,−26,27]+(Δϕ7[3]⋘22)=223−224=−223.

对 Δb2\Delta b_2Δb2 的零位：

(a) c2,17=0c_{2,17}=0c2,17=0 时，可允许 (c2′)NF(c_2')^{NF}(c2′)NF 第 7、12 位与 a2′a_2'a2′ 第 17 位变化而 b2b_2b2 不变：

Δc2NF[7,…,11,−12]+(Δϕ7[17]⋘22)=−26+26=0.\Delta c_2^{NF}[7,\ldots,11,-12]+(\Delta\phi_7[17]\lll 22)=-2^6+2^6=0.Δc2NF[7,…,11,−12]+(Δϕ7[17]⋘22)=−26+26=0.

(b) d2,i=a2,id_{2,i}=a_{2,i}d2,i=a2,i（i∈{1,2,4,5,25,27,29,30,31}i\in\{1,2,4,5,25,27,29,30,31\}i∈{1,2,4,5,25,27,29,30,31}）时，c2Fc_2^Fc2F 第 iii 位可变而 b2b_2b2 不变。
(c) c2,i=1c_{2,i}=1c2,i=1（i∈{13,…,16,18,…,23}i\in\{13,\ldots,16,18,\ldots,23\}i∈{13,…,16,18,…,23}）时，a2a_2a2 第 iii 位可变而 b2b_2b2 不变。
(d) d2,6=a2,6‾=0d_{2,6}=\overline{a_{2,6}}=0d2,6=a2,6=0 时，c2Fc_2^Fc2F 第 6 位可变而 b2b_2b2 不变。
(e) a2,32=1a_{2,32}=1a2,32=1 时，c2Fc_2^Fc2F 与 d2d_2d2 第 32 位可变而 b2b_2b2 不变。
(f) d2,i=0d_{2,i}=0d2,i=0（i∈{8,9,10}i\in\{8,9,10\}i∈{8,9,10}）时，a2a_2a2 与 c2Fc_2^Fc2F 第 iii 位可变而 b2b_2b2 不变。
(g) d2,12=1d_{2,12}=1d2,12=1 时，a2a_2a2 与 c2Fc_2^Fc2F 第 12 位可变而 b2b_2b2 不变。
(h) a2,24=0a_{2,24}=0a2,24=0 时，c2Fc_2^Fc2F 与 d2d_2d2 第 24 位可变而 b2b_2b2 不变。
(i) c2Fc_2^Fc2F、d2d_2d2、a2a_2a2 第 7 位同时变化时，b2b_2b2 仍可不变。

其余步的充分条件可用同样方式推出。

信息修改#

单一信息修改。通过改消息字可提前满足部分充分条件。对 M0M_0M0（或 M1M_1M1）及相应中间链接值，可修改消息使表 4、表 6 中第一阶段（前 16 步）条件几乎必然成立。例如为满足表 4 中 c1c_1c1 的三个条件，可令

c1new←c1old−c1,7old⋅26−c1,12old⋅211−c1,20old⋅219,m2new←((c1new−c1old)⋙17)+m2old.\begin{aligned} c_1^{\mathrm{new}}&\leftarrow c_1^{\mathrm{old}}-c_{1,7}^{\mathrm{old}}\cdot 2^6-c_{1,12}^{\mathrm{old}}\cdot 2^{11}-c_{1,20}^{\mathrm{old}}\cdot 2^{19}, \\ m_2^{\mathrm{new}}&\leftarrow\bigl((c_1^{\mathrm{new}}-c_1^{\mathrm{old}})\ggg 17\bigr)+m_2^{\mathrm{old}}. \end{aligned}c1newm2new←c1old−c1,7old⋅26−c1,12old⋅211−c1,20old⋅219,←((c1new−c1old)⋙17)+m2old.

对 M0M_0M0 各字做完修改后，第一阶段条件成立，第一块差分概率约为 2−432^{-43}2−43；对 M1M_1M1 类似修改后，第二块约为 2−372^{-37}2−37。

多重信息修改。还可满足部分前 32 步条件。例如若 a5,32=1a_{5,32}=1a5,32=1，可改 m1,…,m5m_1,\ldots,m_5m1,…,m5 使其变为 000，从而在第 2–6 步形成局部碰撞且不破坏第一阶段条件（见表 1）。之后表 4 第 2–4 阶段约剩 37 个未定条件，表 6 约剩 30 个，故两块差分概率分别约为 2−372^{-37}2−37 与 2−302^{-30}2−30。

攻击流程#

目标是实现

ΔH0→(M0,M0′), 2−37ΔH1→(M1,M1′), 2−30ΔH=0.\Delta H_0 \xrightarrow{(M_0,M_0'),\,2^{-37}} \Delta H_1 \xrightarrow{(M_1,M_1'),\,2^{-30}} \Delta H=0.ΔH0(M0,M0′),2−37ΔH1(M1,M1′),2−30ΔH=0.

重复直至找到 M0M_0M0：随机取 M0M_0M0 → 信息修改 → 令 M0′=M0+ΔM0M_0'=M_0+\Delta M_0M0′=M0+ΔM0 检验第一块差分（概率约 2−372^{-37}2−37）→ 用压缩函数核对特征。
重复直至碰撞：随机取 M1M_1M1 → 信息修改 → 用 M1M_1M1 与 M1+ΔM1M_1+\Delta M_1M1+ΔM1 检验第二块差分（概率约 2−302^{-30}2−30）→ 检查是否碰撞。

实现上，M0′M_0'M0′ 只需改 M0M_0M0 最后两字；前 14 字的单一修改开销可忽略。对每个候选 M0M_0M0，约需对最后两字各做一次单一修改，并在第二阶段做约 7 次多重修改，总时间不超过约两次 MD5。计入这些后，搜索 (M0,M0′)(M_0,M_0')(M0,M0′) 的复杂度不超过约 2392^{39}239 次 MD5。

表 2 给出两个碰撞实例：二者第一块完全相同；一旦第一块满足条件，第二块通常很容易找到。

总结#

上述模差方法使寻找 MD5 碰撞变得现实可行，并可用于其它哈希。论文给出的粗略复杂度如下（不含 / 含多重信息修改）：

MD4：约 2232^{23}223 / 282^{8}28 次 MD4；
HAVAL-128：约 2132^{13}213 / 272^{7}27 次；
RIPEMD：约 2302^{30}230 / 2182^{18}218 次；
SHA-0：约 2612^{61}261 / 2452^{45}245 次。

附录：原文表格截图#

图表说明

下列截图依次对应正文中的表 1–6（信息修改示例、碰撞实例、差分特征与充分条件等）。

表 1 多重信息修改示例

表 2 MD5 碰撞实例

表 3 第一块消息的差分特征

表 4 第一块相关充分条件

表 5 第二块消息的差分特征

表 6 第二块相关充分条件

参考文献#

Footnotes#

Xiaoyun Wang, Hongbo Yu. How to Break MD5 and Other Hash Functions. EUROCRYPT 2005. ↩

Trained Quantization Thresholds (TQT)

Thu, 02 Dec 2021 00:00:00 GMT

阅读说明

个人论文阅读报告留档：介绍发表于 MLSys 2020 的论文 TQT（Trained Quantization Thresholds），一种基于 QAT 学习均匀、对称、per-tensor 量化截断阈值的方法。

论文信息

Title: Trained Quantization Thresholds for Accurate and Efficient Fixed-point Inference of Deep Neural Networks
Venue: MLSys 2020
Author(s): Sambhav R. Jain, Albert Gural, Michael Wu, Chris H. Dick
Institution(s): Xilinx Inc, Stanford University
Link: arXiv:1903.08066
Project: Graffitist、Vitis-AI Quantizer

引言#

本文提出 Trained Quantization Thresholds（TQT）¹：一种基于量化感知训练（Quantization-Aware Training, QAT），学习均匀（Uniform）、对称（Symmetric）、张量级（per-tensor）量化器截断阈值的方法。TQT 在训练时使用直通估计器（Straight-Through Estimator, STE）²，并将量化步长限制为 2 的幂次（Power-of-Two, PoT）。采用 PoT 步长后，推理阶段可用整型加法与移位完成缩放，便于硬件部署。作者对 TQT 的鲁棒性做了数学分析，并在 ImageNet（ILSVRC 2012）图像分类任务上对多个 CNN 进行了实验。结果表明：在 MobileNet 等以往较难量化的网络上，TQT 往往只需少于 5 个 epoch 的再训练，即可达到接近浮点模型的精度。

本文主要关注以下三个问题：

此前大量工作依赖后训练量化（Post-Training Quantization, PTQ）的静态校准：校准得到的截断阈值在之后保持固定，相对 QAT 学到的阈值，泛化往往更弱。
PTQ 中按 per-tensor / per-channel 定义的量化误差指标（如 KLD、MSE）多属经验设计，与最终任务损失是否相关仍缺乏严格理论保证。相较优化人工指标的 PTQ，基于训练的方法通常更有效，也更易从优化目标上解释。
Google 的 Integer-Only Inference³ 方案中，比例系数 MMM 为 dyadic 形式而非 PoT，仍可能带来高位整型存储与乘法开销。更理想的全整型推理可将量化步长限制为 PoT，从而用移位完全替代步长乘法，更利于硬件加速。

相关工作主要包括 STE²、Integer-Arithmetic-Only Inference³、PACT⁴，以及同期的 LSQ⁵ 等。

方法#

量化器约束#

TQT 采用的均匀量化公式如下：

r=s⋅(q−z)r = s \cdot (q - z)r=s⋅(q−z)

其中 sss 为量化步长，zzz 为量化零点，qqq 为量化后的整型数值。为简化运算，TQT 采用对称量化并令 z=0z=0z=0，从而省略含零点的展开项：

r=s⋅qr = s \cdot qr=s⋅q

同时，TQT 要求量化步长 sss 为 PoT 形式，即 s=2−fs=2^{-f}s=2−f，其中 fff 为 fractional length（可理解为定点小数点位置），是一个有符号整数。这样计算 r=s⋅qr = s \cdot qr=s⋅q 时可用移位代替乘法。

前向传播#

TQT 的量化前向包含缩放（Scaling）、取整（Rounding）、截断（Saturation）、反量化（De-quantization）四步，量化函数为：

q(x;s)=clip(⌊xs⌉;n,p)⋅sq(x;s)=\text{clip} \left( \left\lfloor \frac{x}{s} \right\rceil ;n,p \right)\cdot sq(x;s)=clip(⌊sx⌉;n,p)⋅s

其中 q(x;s)q(x;s)q(x;s) 为量化函数，xxx 为输入张量，sss 为量化步长，clip\text{clip}clip 为区间截断，nnn 与 ppp 分别为区间下界与上界。量化参数取值取决于输入是否有符号：

有符号（signed）：

n=−2b−1,p=2b−1−1,s=2⌈log⁡2t⌉2b−1n=-2^{b-1}, \quad p=2^{b-1}-1, \quad s=\frac{2^{\left\lceil \log_2 t \right\rceil}}{2^{b-1}}n=−2b−1,p=2b−1−1,s=2b−12⌈log2t⌉

无符号（unsigned）：

n=0,p=2b−1,s=2⌈log⁡2t⌉2bn=0, \quad p=2^b-1, \quad s=\frac{2^{\left\lceil \log_2 t \right\rceil}}{2^b}n=0,p=2b−1,s=2b2⌈log2t⌉

其中 ttt 为原始量化截断阈值；实际使用的截断范围取不小于 ttt 的最小 PoT 值 2⌈log⁡2t⌉2^{\left\lceil \log_2 t \right\rceil}2⌈log2t⌉。

反向传播#

训练中同时优化输入 xxx 与量化步长 sss。为便于写出梯度，可将前向中的 clip\text{clip}clip 改写为分段形式：

q(x;s)={⌊xs⌉⋅sif n≤⌊xs⌉≤p,n⋅sif ⌊xs⌉<n,p⋅sif ⌊xs⌉>p.q(x;s)= \begin{cases} \left\lfloor \dfrac{x}{s} \right\rceil \cdot s & \text{if } n\leq\left\lfloor \dfrac{x}{s} \right\rceil \leq p, \\[0.5em] n\cdot s & \text{if } \left\lfloor \dfrac{x}{s} \right\rceil < n, \\[0.5em] p\cdot s & \text{if } \left\lfloor \dfrac{x}{s} \right\rceil > p. \end{cases}q(x;s)=⎩⎨⎧⌊sx⌉⋅sn⋅sp⋅sif n≤⌊sx⌉≤p,if ⌊sx⌉<n,if ⌊sx⌉>p.

反向传播时，对不可微的取整运算采用 STE²：当 ⌈x⌉≠x\lceil x \rceil \neq x⌈x⌉=x、⌊x⌋≠x\lfloor x \rfloor \neq x⌊x⌋=x、⌊x⌉≠x\left\lfloor x \right\rceil \neq x⌊x⌉=x 时，令

∂⌈x⌉∂x=∂⌊x⌋∂x=∂⌊x⌉∂x=1.\frac{\partial \lceil x \rceil}{\partial x} = \frac{\partial \lfloor x \rfloor}{\partial x} = \frac{\partial \left\lfloor x \right\rceil}{\partial x} = 1.∂x∂⌈x⌉=∂x∂⌊x⌋=∂x∂⌊x⌉=1.

由此得到 qqq 关于 sss 的梯度：

∇sq(x;s)={⌊xs⌉−xsif n≤⌊xs⌉≤p,nif ⌊xs⌉<n,pif ⌊xs⌉>p.\nabla_s q(x;s)= \begin{cases} \left\lfloor \dfrac{x}{s} \right\rceil - \dfrac{x}{s} & \text{if } n\leq\left\lfloor \dfrac{x}{s} \right\rceil \leq p, \\[0.5em] n & \text{if } \left\lfloor \dfrac{x}{s} \right\rceil < n, \\[0.5em] p & \text{if } \left\lfloor \dfrac{x}{s} \right\rceil > p. \end{cases}∇sq(x;s)=⎩⎨⎧⌊sx⌉−sxnpif n≤⌊sx⌉≤p,if ⌊sx⌉<n,if ⌊sx⌉>p.

注意到 ∇log⁡2ts=sln⁡2\nabla_{\log_2 t} s = s \ln 2∇log2ts=sln2，上式可写为：

∇log⁡2tq(x;s)=sln⁡2⋅{⌊xs⌉−xsif n≤⌊xs⌉≤p,nif ⌊xs⌉<n,pif ⌊xs⌉>p.\nabla _{\log_2 t} q(x;s)=s \ln 2 \cdot \begin{cases} \left\lfloor \dfrac{x}{s} \right\rceil - \dfrac{x}{s} & \text{if } n\leq\left\lfloor \dfrac{x}{s} \right\rceil \leq p, \\[0.5em] n & \text{if } \left\lfloor \dfrac{x}{s} \right\rceil < n, \\[0.5em] p & \text{if } \left\lfloor \dfrac{x}{s} \right\rceil > p. \end{cases}∇log2tq(x;s)=sln2⋅⎩⎨⎧⌊sx⌉−sxnpif n≤⌊sx⌉≤p,if ⌊sx⌉<n,if ⌊sx⌉>p.

同理，xxx 的梯度为：

∇xq(x;s)={1if n≤⌊xs⌉≤p,0otherwise.\nabla _x q(x;s)= \begin{cases} 1 & \text{if } n \leq \left\lfloor \dfrac{x}{s} \right\rceil \leq p, \\[0.5em] 0 & \text{otherwise}. \end{cases}∇xq(x;s)=⎩⎨⎧10if n≤⌊sx⌉≤p,otherwise.

梯度含义解读#

上面给出了量化器 qqq 对 xxx 与 log⁡2t\log_2 tlog2t 的梯度。为直观理解 QAT 中的梯度行为，考虑用最小二乘损失

L=(q(x;s)−x)22L = \frac{(q(x;s) - x)^2}{2}L=2(q(x;s)−x)2

优化一个 TQT 量化器。此时：

∇log⁡2tL=(q(x;s)−x)⋅∇log⁡2tq(x;s)∇xL=(q(x;s)−x)⋅(∇xq(x;s)−1)\begin{align*} \nabla _{\log_2 t} L &= (q(x;s) - x) \cdot \nabla _{\log_2 t} q(x;s) \\ \nabla _x L &= (q(x;s) - x) \cdot (\nabla _x q(x;s) - 1) \end{align*}∇log2tL∇xL=(q(x;s)−x)⋅∇log2tq(x;s)=(q(x;s)−x)⋅(∇xq(x;s)−1)

图 1 b=3, t=1.0 时有符号和无符号情形下的函数值与各参数梯度

图 1 展示了 b=3, t=1.0b=3,\,t=1.0b=3,t=1.0 时有符号与无符号情况下的函数值及各参数梯度曲线：第一行为量化函数，第二行为损失函数。由于取整 ⌊⋅⌉\left\lfloor\cdot\right\rceil⌊⋅⌉ 与截断 clip\text{clip}clip 共同作用，输入 xxx 的有效范围实际为 [s⋅(n−0.5), s⋅(p+0.5)][s\cdot(n-0.5),\,s\cdot(p+0.5)][s⋅(n−0.5),s⋅(p+0.5)]。从图 1 可以看出：

当 xxx 落在有效范围内时，LLL 对 log⁡2t\log_2 tlog2t 的梯度非负，对 xxx 的梯度为 000；
当 xxx 落在有效范围外时，LLL 对 log⁡2t\log_2 tlog2t 的梯度恒负，对 xxx 的梯度左负右正。

图 2 钟型分布输入下 log_2 t 梯度的典型情形

图 2 展示了输入 xxx 呈钟型分布（如高斯）时，log⁡2t\log_2 tlog2t 梯度的典型情形：

左图：绝大多数 xxx 落在有效范围内，对 log⁡2t\log_2 tlog2t 的累计梯度为正，梯度下降使 log⁡2t\log_2 tlog2t 减小并向分布中心靠近；
中图：落在范围外的样本对 log⁡2t\log_2 tlog2t 产生负累计梯度，使阈值向外扩大；
右图：收敛时正负梯度相互抵消，此时截断阈值为 PoT，并能在精度损失与截断范围之间取得较好折中。

TQT 在 QAT 中也会同时优化输入 xxx。与阈值梯度类似：

范围内：LLL 对 xxx 的梯度为 000，范围内输入保持不变；
范围外：LLL 对 xxx 的梯度左负右正，使离群点向分布中心收缩。

与其它截断阈值梯度方法的比较#

与 TensorFlow FakeQuant 的比较#

图 3 FakeQuant 在 b=3, n=-1.125, p=0.875 时的函数与梯度

TensorFlow 伪量化模块 FakeQuant 参考的量化函数为：

q(x;n,p)=⌊clip(x;n,p)−np−n2b−1⌉⋅p−n2b−1+nq(x;n,p)=\left\lfloor \frac{\text{clip}(x;n,p)-n}{\frac{p-n}{2^b-1}} \right\rceil \cdot \frac{p-n}{2^b-1} + nq(x;n,p)=⌊2b−1p−nclip(x;n,p)−n⌉⋅2b−1p−n+n

图 3 给出了 b=3, n=−1.125, p=0.875b=3,\,n=-1.125,\,p=0.875b=3,n=−1.125,p=0.875 时 FakeQuant 的函数与梯度。与 TQT 不同，FakeQuant 直接学习截断端点 nnn 与 ppp，反向时将取整近似为恒等映射。由图可见，nnn 与 ppp 的梯度恒为正，梯度下降只能使边界向外扩张，结果更接近 PTQ 的 min/max，难以在精度与截断范围之间主动折中。

与 PACT 的比较#

PACT⁴（PArameterized Clipping acTivation）通过可学习的 Clipped ReLU 将截断阈值引入 QAT：

y=PACT(x)=0.5(∣x∣−∣x−α∣+α)={0,x∈(−∞,0)x,x∈[0,α)α,x∈[α,+∞)y=\mathrm{PACT}(x)=0.5\big(|x|-|x-\alpha|+\alpha\big)= \begin{cases} 0, & x \in (-\infty, 0) \\ x, & x \in [0, \alpha) \\ \alpha, & x \in [\alpha, +\infty) \end{cases}y=PACT(x)=0.5(∣x∣−∣x−α∣+α)=⎩⎨⎧0,x,α,x∈(−∞,0)x∈[0,α)x∈[α,+∞)

输出对截断阈值 α\alphaα 的梯度经 STE 近似为：

∂yq∂α={0,x∈(−∞,α)1,x∈[α,+∞)\frac{\partial y_q}{\partial \alpha} = \begin{cases} 0, & x \in (-\infty, \alpha) \\ 1, & x \in [\alpha, +\infty) \end{cases}∂α∂yq={0,1,x∈(−∞,α)x∈[α,+∞)

在 PACT 中，α\alphaα 的梯度仅取决于 xxx 落在 α\alphaα 的哪一侧：只有右侧样本会推动 α\alphaα，因而训练中 α\alphaα 易趋向样本右端最大值。为抑制该现象，PACT 在损失中对 α\alphaα 加入 L2 正则，但系数 λα\lambda_{\alpha}λα 需人工设定，无法像 TQT 那样在训练中自动权衡截断与精度。

框架实现#

与本文配套的 Graffitist 基于 TensorFlow 实现了端到端的 TQT 量化流程，支持多种网络的计算图优化与量化。

Xilinx

graffitist

Waiting for api.github.com...

00K

Waiting...

计算图优化：包括 BN 融合、多重 concat 合并为单一 concat、将平均池化改写为深度卷积等。
量化模式：支持 PTQ 静态量化与基于 TQT 的 QAT 等模式。
层精度配置：可分别针对计算层、激活层、平均池化与 concat 等操作配置量化位宽。
融合内核：提供面向 CPU/GPU 预编译的融合量化内核，降低量化器内存占用，从而可用更大 batch size 加速训练。

实验#

此处仅展示主要结果；初始化与实现细节见原论文。

结果#

表 3 多种网络在 ImageNet 上的验证准确率

表 3 给出了 12 种网络在 ImageNet 分类任务上的验证准确率。wt 表示只再训练权重；wt,th 表示权重与截断阈值同时训练。所有再训练均不超过 5 个 epoch。

讨论#

来自 TQT 的观察#

QAT 精度通常高于 PTQ 静态量化，符合预期。
对 VGG、Inception、ResNet 等 INT8 相对容易的模型，固定阈值、只训权重往往已足够；再引入 TQT 未必带来额外收益。
对 MobileNet、DarkNet 等 INT8 较难的模型，同时训练权重与阈值可比只训权重高出约 4%4\%4%，甚至接近 FP32。
对更低比特的 INT4，只训权重已很难恢复精度，通常必须配合 TQT 才能稳住精度。

MobileNet 对比#

表 1 MobileNet 上与 Google QAT 等方法的对比

对较难量化的 MobileNet，已有工作表明：简单的对称、per-tensor PTQ 往往效果很差。原因之一是深度可分离卷积的权重分布不规则，且通道间动态范围差异大。使用 TQT（wt,th）做 QAT 后，精度可接近 FP32。与 Google QAT 等结果对比如表 1：尽管 TQT 对步长的约束更严（PoT），精度反而更高。

图 5 MobileNet v1 经 TQT 再训练前后的权重分布

图 5 展示了 TQT 再训练前后 MobileNet v1 的权重分布，体现了截断范围与精度之间的折中。

图 6 INT8 / INT4 下各层 fractional length 的始末差异

图 6 给出 INT8 与 INT4 量化时各层 fractional length 的始末差异。INT8 下 fractional length 的变化往往更大：比特更充裕时方法更倾向扩大截断范围；比特更少时，扩大范围与保精度的折中更为尖锐。

总结#

本文介绍了一种通用的量化截断阈值学习方法 TQT，主要特点包括：

可将量化步长限制为 PoT，适配多数定点硬件；
学习过程显式体现截断范围与精度的折中，在 INT8 / INT4 上均可取得较高精度；
具有较好的鲁棒性与较快的收敛速度。

作者基于 TensorFlow 实现了 Graffitist，并在 ImageNet 上对多种经典模型做了量化实验，同时对若干实验现象进行了讨论。

附录#

附录内容简要如下。

A 仿射量化器的开销#

讨论量化器计算开销。A.1 分析量化乘法，说明省略零点 zzz 可降低复杂度；A.2 比较浮点、dyadic 与 PoT 步长下的乘法：dyadic 见 Google Integer-Only Inference³，PoT 可用移位替代乘法。

B 对数阈值训练#

从数值稳定性、尺度不变性与收敛性讨论在 log⁡2t\log_2 tlog2t 空间训练阈值：

B.1 数值稳定性（Numerical Stability）：相对直接优化 t∈R+t\in\mathbb{R}^+t∈R+，优化 log⁡2t∈R\log_2 t\in\mathbb{R}log2t∈R 更稳，且与 PoT 形式一致；
B.2 尺度不变性（Scale Invariance）：希望梯度尽量与取值量级解耦；
B.3 收敛性（Convergence）：并给出不同比特下 Adam 超参参考。

C Adam 收敛性#

进一步分析 TQT 在 Adam 上的收敛行为。

D 最优验证与平均验证#

解释结果筛选方式。MobileNetV1 与 VGG16 上，1000 次验证的平均准确率与最高准确率差距分别约为 0.1%0.1\%0.1% 与 0.2%0.2\%0.2%，说明结果较为稳定可靠。

参考文献#

Footnotes#

全组合算法（Full Combination）

Fri, 17 May 2019 00:00:00 GMT

定义#

从含 nnn 个元素的集合 A={a1,⋯ ,an}A = \{a_1, \cdots, a_n\}A={a1,⋯,an} 中任取 mmm（0≤m≤n0 \leq m \leq n0≤m≤n）个元素，组成的子集称为组合（Combination）。当 m<nm < nm<n 时，组合数为

Cnm=(nm)=n!m!(n−m)!.C_n^m = \binom{n}{m} = \frac{n!}{m!(n-m)!}.Cnm=(mn)=m!(n−m)!n!.

给定集合 AAA 和 mmm 时，所有可能的组合构成的集合称为全组合（Full Combination）。全组合的实现同样可分递归（回溯）与非递归。下文默认集合元素为 0,⋯ ,N−10, \cdots, N-10,⋯,N−1（与代码一致）；若要使用 1,⋯ ,N1, \cdots, N1,⋯,N，初始化时改为 a[i] = i + 1 即可。

递归实现#

1. 递归回溯法#

由组合恒等式出发

Cnm=Cn−1m+Cn−1m−1C_n^m = C_{n-1}^m + C_{n-1}^{m-1}Cnm=Cn−1m+Cn−1m−1

可把从 nnn 个元素中取 mmm 个元素拆解成一系列与单一元素 aia_iai 相关的两个子问题：

不选 aia_iai：在剩余 n−1n-1n−1 个中取 mmm 个 ⇒Cn−1m\Rightarrow C_{n-1}^m⇒Cn−1m；
选 aia_iai：在剩余 n−1n-1n−1 个中再取 m−1m-1m−1 个 ⇒Cn−1m−1\Rightarrow C_{n-1}^{m-1}⇒Cn−1m−1。

递归边界：已取满 mmm 个则输出；下标越界且未取满则失败返回。实现上是回溯：先试探选中当前元素，再试探不选；对应递归调用中，先递归调用不选，再递归调用选。

1
#include <iostream>
2
#include <vector>
3
using namespace std;
4

5
vector<int> res;
6
int N, M;
7
int *a;
8

9
void print() {
10
    for (int i = 0; i < (int)res.size(); ++i) {
11
        cout << res[i] << ' ';
12
    }
13
    cout << endl;
14
}
15

16
// k：当前考虑的下标；m：还需要再取多少个（此处用 res.size() 与 M 判断亦可）
17
void combination(int k, int m) {
18
    if ((int)res.size() == M) {
19
        print();
20
        return;
21
    }
22
    if (k >= N) {
23
        return;
24
    }
25
    res.push_back(a[k]);
26
    combination(k + 1, m - 1); // 选
27
    res.pop_back();
28
    combination(k + 1, m);     // 不选
29
}
30

31
int main() {
32
    cin >> N >> M;
33
    a = new int[N];
34
    for (int i = 0; i < N; ++i) {
35
        a[i] = i;
36
    }
37
    combination(0, M);
38
    delete[] a;
39
    return 0;
40
}

展开收起

2. 顺序法（递归）#

更常见的写法：强制按递增下标选取，避免同一子集因顺序不同被重复枚举。先取第 111 个元素可选范围为下标 [0,N−M][0, N-M][0,N−M]，再递归取后续；当还剩 111 个名额时，遍历剩余元素并输出。

1
#include <iostream>
2
#include <vector>
3
using namespace std;
4

5
vector<int> res;
6
int N, M;
7
int *a;
8

9
void print() {
10
    for (int i = 0; i < (int)res.size(); ++i) {
11
        cout << res[i] << ' ';
12
    }
13
    cout << endl;
14
}
15

16
void combination(int k, int m) {
17
    if (m == 1) {
18
        for (int i = k; i < N; ++i) {
19
            res.push_back(a[i]);
20
            print();
21
            res.pop_back();
22
        }
23
        return;
24
    }
25
    for (int i = k; i <= N - m; ++i) {
26
        res.push_back(a[i]);
27
        combination(i + 1, m - 1);
28
        res.pop_back();
29
    }
30
}
31

32
int main() {
33
    cin >> N >> M;
34
    a = new int[N];
35
    for (int i = 0; i < N; ++i) {
36
        a[i] = i;
37
    }
38
    combination(0, M);
39
    delete[] a;
40
    return 0;
41
}

展开收起

非递归实现#

3. 顺序法（嵌套循环）#

用 mmm 层循环，每层选一个严格递增的下标。与全排列里的蛮力法一样：层数绑死 mmm，改 mmm 就要改代码。

以 m=3m = 3m=3 为例：

1
#include <iostream>
2
#include <vector>
3
using namespace std;
4

5
vector<int> res;
6
int N;
7
int M = 3;
8
int *a;
9

10
void print() {
11
    for (int i = 0; i < (int)res.size(); ++i) {
12
        cout << res[i] << ' ';
13
    }
14
    cout << endl;
15
}
16

17
int main() {
18
    cin >> N;
19
    a = new int[N];
20
    for (int i = 0; i < N; ++i) {
21
        a[i] = i;
22
    }
23
    for (int i1 = 0; i1 < N - 2; ++i1) {
24
        res.push_back(a[i1]);
25
        for (int i2 = i1 + 1; i2 < N - 1; ++i2) {
26
            res.push_back(a[i2]);
27
            for (int i3 = i2 + 1; i3 < N; ++i3) {
28
                res.push_back(a[i3]);
29
                print();
30
                res.pop_back();
31
            }
32
            res.pop_back();
33
        }
34
        res.pop_back();
35
    }
36
    delete[] a;
37
    return 0;
38
}

展开收起

4. 状态序列 + 全排列#

对于每个元素 aia_iai，只有在与不在子集中两种状态。可构造长度为 nnn、恰含 mmm 个 1 与 n−mn-mn−m 个 0 的状态串 CCC，CCC 的每一种不同排列对应一种组合。那么问题就转换为了求 CCC 的互异全排列问题。

例：A={1,2,3,4}A=\{1,2,3,4\}A={1,2,3,4}，m=2m=2m=2，初始 C={1,1,0,0}C=\{1,1,0,0\}C={1,1,0,0}，用字典序/反字典序枚举 CCC 的互异排列：

状态 CCC	取出的元素
1,1,0,01,1,0,01,1,0,0	1,21,21,2
1,0,1,01,0,1,01,0,1,0	1,31,31,3
1,0,0,11,0,0,11,0,0,1	1,41,41,4
0,1,1,00,1,1,00,1,1,0	2,32,32,3
0,1,0,10,1,0,10,1,0,1	2,42,42,4
0,0,1,10,0,1,10,0,1,1	3,43,43,4

全排列算法见全排列一文。非递归时可用 prev_permutation / next_permutation 枚举状态串：

1
#include <iostream>
2
#include <algorithm>
3
#include <vector>
4
#include <string>
5
using namespace std;
6

7
vector<int> res;
8
int N, M;
9
int *a;
10
string b;
11

12
void print() {
13
    for (int i = 0; i < (int)res.size(); ++i) {
14
        cout << res[i] << ' ';
15
    }
16
    cout << endl;
17
}
18

19
int main() {
20
    cin >> N >> M;
21
    a = new int[N];
22
    b.append(M, '1').append(N - M, '0');
23
    for (int i = 0; i < N; ++i) {
24
        a[i] = i;
25
    }
26
    do {
27
        for (int i = 0; i < N; ++i) {
28
            if (b[i] == '1') {
29
                res.push_back(a[i]);
30
            }
31
        }
32
        print();
33
        res.clear();
34
    } while (prev_permutation(b.begin(), b.end()));
35
    delete[] a;
36
    return 0;
37
}

展开收起

提示

next_permutation / prev_permutation 在有重复元素时只会生成互异排列，因此对 mmm 个 111、n−mn-mn−m 个 000 的串，枚举次数是 CnmC_n^mCnm 而非 n!n!n!。

全排列算法（Full Permutation）

Mon, 06 May 2019 00:00:00 GMT

定义#

给定无重复元素序列 {an}\{a_n\}{an}，即满足：

1≤i,j≤n∧i≠j⇒ai≠aj,1 \leq i,j \leq n \land i \neq j \Rightarrow a_i \neq a_j,1≤i,j≤n∧i=j⇒ai=aj,

从中任取 mmm（m≤nm \leq nm≤n）个元素并按顺序排成一列，得到的所有结果称为排列（Permutation / Arrangement）。当 m<nm < nm<n 时，排列数为

Anm=n!(n−m)!A_n^m = \frac{n!}{(n-m)!}Anm=(n−m)!n!

当 m=nm = nm=n 时称为全排列（Full Permutation），排列数为

Ann=n!A_n^n = n!Ann=n!

全排列的实现可分为递归与非递归两类。下文示例默认序列元素为 1,⋯ ,n1, \cdots, n1,⋯,n 的整数；换成字符等其它可比较类型亦可。

递归实现#

1. 交换法#

由 Ann=n⋅An−1n−1A_n^n = n \cdot A_{n-1}^{n-1}Ann=n⋅An−1n−1：将 {an}\{a_n\}{an} 中每个元素依次固定到某一位置（通常是当前位置 kkk），再对剩余 n−1n-1n−1 个元素求全排列，直到只剩一个元素。

以 {1,2,3}\{1,2,3\}{1,2,3} 为例，先固定首位：

交换	结果
a0↔a0a_0 \leftrightarrow a_0a0↔a0	1,2,31,2,31,2,3
a0↔a1a_0 \leftrightarrow a_1a0↔a1	2,1,32,1,32,1,3
a0↔a2a_0 \leftrightarrow a_2a0↔a2	3,2,13,2,13,2,1

再对每个结果的后两位继续交换，最终得到全部 3!=63! = 63!=6 种排列。

步骤：

固定位索引 k=0k = 0k=0；
对所有 i∈[k,n)i \in [k, n)i∈[k,n)，交换 aka_kak 与 aia_iai，再递归处理 k+1k+1k+1；
递归返回后交换回来（回溯）；
当 k=n−1k = n-1k=n−1 时输出一种排列。

1
#include <iostream>
2
using namespace std;
3

4
int n;
5

6
void swap(int *a, int *b) {
7
    *a ^= *b;
8
    *b ^= *a;
9
    *a ^= *b;
10
}
11

12
void permutation(int array[], int k) {
13
    if (k == n - 1) {
14
        for (int i = 0; i < n; i++) {
15
            cout << array[i] << ' ';
16
        }
17
        cout << endl;
18
    } else {
19
        for (int i = k; i < n; i++) {
20
            swap(&array[i], &array[k]);
21
            permutation(array, k + 1);
22
            swap(&array[i], &array[k]);
23
        }
24
    }
25
}
26

27
int main() {
28
    cin >> n;
29
    int a[n];
30
    for (int i = 0; i < n; ++i) {
31
        a[i] = i + 1;
32
    }
33
    permutation(a, 0);
34
    return 0;
35
}

展开收起

注意即便输入已是字典序，交换法得到的输出顺序一般也不是字典序。

复杂度： 递归会到达 n!n!n! 个叶结点；若每次输出花费 O(n)O(n)O(n)，生成全部全排列的时间为 O(n⋅n!)O(n \cdot n!)O(n⋅n!)。递归深度为 O(n)O(n)O(n)，除输入数组外额外栈空间为 O(n)O(n)O(n)。

2. 递归生成树法#

另一视角：Ann=∏k=1nCk1A_n^n = \prod_{k=1}^{n} C_k^1Ann=∏k=1nCk1。维护一个栈：每次从剩余元素中取一个入栈，递归；返回后出栈并把元素放回。对序列 {a3}=\{a_3\} = {a3}={1,2,3}$ 可画出递归生成树，根到叶的每条路径对应一种排列：

123

132

213

231

312

321

123

132

213

231

312

321

用 vector 容器同时表示剩余序列与结果栈，即可实现递归生成树法：

1
#include <iostream>
2
#include <vector>
3
using namespace std;
4

5
vector<int> res;
6
vector<int> a;
7
int n;
8

9
void permutation(int k) {
10
    if (k == 0) {
11
        for (int i = 0; i < n; ++i) {
12
            cout << res[i] << ' ';
13
        }
14
        cout << endl;
15
    } else {
16
        for (int i = 0; i < k; ++i) {
17
            res.push_back(a[i]);
18
            a.erase(a.begin() + i);
19
            permutation(k - 1);
20
            a.insert(a.begin() + i, res.back());
21
            res.pop_back();
22
        }
23
    }
24
}
25

26
int main() {
27
    cin >> n;
28
    for (int i = 0; i < n; ++i) {
29
        a.push_back(i + 1);
30
    }
31
    permutation(n);
32
    return 0;
33
}

展开收起

vector 的 erase / insert 会使后续元素整体移动，常数较大；可用链表降低移动开销，但实现更繁琐。生成全部排列并输出时，时间仍至少是 O(n⋅n!)O(n \cdot n!)O(n⋅n!) 量级，额外空间 O(n)O(n)O(n)。

非递归实现#

3. 穷举法#

穷举法的思路与递归生成树类似：用 nnn 层嵌套循环依次选位置，并用条件排除重复。但其缺陷也很明显：代码的循环层数绑死 nnn，一般只适用于 nnn 固定的情况。

n=5n = 5n=5 时示意代码如下：

1
#include <iostream>
2
using namespace std;
3

4
int n = 5;
5

6
int main() {
7
    int a[n];
8
    for (int i = 0; i < n; ++i) {
9
        a[i] = i + 1;
10
    }
11
    for (int i1 = 0; i1 < n; ++i1) {
12
        for (int i2 = 0; i2 < n; ++i2) {
13
            if (a[i1] == a[i2]) continue;
14
            for (int i3 = 0; i3 < n; ++i3) {
15
                if (a[i1] == a[i3] || a[i2] == a[i3]) continue;
16
                for (int i4 = 0; i4 < n; ++i4) {
17
                    if (a[i1] == a[i4] || a[i2] == a[i4] || a[i3] == a[i4]) continue;
18
                    for (int i5 = 0; i5 < n; ++i5) {
19
                        if (a[i1] == a[i5] || a[i2] == a[i5] || a[i3] == a[i5] || a[i4] == a[i5]) continue;
20
                        cout << a[i1] << ' ' << a[i2] << ' ' << a[i3] << ' '
21
                             << a[i4] << ' ' << a[i5] << endl;
22
                    }
23
                }
24
            }
25
        }
26
    }
27
    return 0;
28
}

展开收起

若输入无重复且按字典序给出，输出也会按字典序。嵌套循环的搜索规模约为 O(nn)O(n^n)O(nn) 量级，额外空间 O(n)O(n)O(n)。

4. 字典序法（`next_permutation` / `prev_permutation`）#

n!n!n! 种全排列可排成字典序序列 {Pk}\{P_k\}{Pk}：

P1P_1P1：原序列的字典序最小排列；
Pn!P_{n!}Pn!：反字典序（字典序最大）；
PkP_kPk 可由 Pk−1P_{k-1}Pk−1 通过求下一个排列得到。

例如 {A,B,C,D,E,F}\{A,B,C,D,E,F\}{A,B,C,D,E,F}：P1=ABCDEFP_1 = ABCDEFP1=ABCDEF，P2=ABCDFEP_2 = ABCDFEP2=ABCDFE，…，P720=FEDCBAP_{720} = FEDCBAP720=FEDCBA。

C++ <algorithm> 提供 next_permutation / prev_permutation。常见用法：

先 sort 成升序，再循环 next_permutation 直到返回 false；
或先变成降序，再循环 prev_permutation；
也可从任意排列双向扫完所有排列。

1
#include <iostream>
2
#include <algorithm>
3
#include <string>
4
using namespace std;
5

6
void print(const string &s) {
7
    for (char c : s) {
8
        cout << c << ' ';
9
    }
10
    cout << endl;
11
}
12

13
void LFP(string str) { // Lexicographical Full Permutation
14
    sort(str.begin(), str.end());
15
    do {
16
        print(str);
17
    } while (next_permutation(str.begin(), str.end()));
18
}
19

20
void RLFP(string str) { // Reverse Lexicographical Full Permutation
21
    sort(str.begin(), str.end());
22
    reverse(str.begin(), str.end());
23
    do {
24
        print(str);
25
    } while (prev_permutation(str.begin(), str.end()));
26
}
27

28
int main() {
29
    string str;
30
    cin >> str;
31
    LFP(str);
32
    RLFP(str);
33
    return 0;
34
}

展开收起

next_permutation 步骤（有重复元素时用 ≤\leq≤ / ≥\geq≥ 亦可）：

从右往左找最大下标 kkk，使 ak<ak+1a_k < a_{k+1}ak<ak+1（找不到则已是最后一项）；
从右往左找最大下标 j>kj > kj>k，使 ak<aja_k < a_jak<aj；
交换 aka_kak 与 aja_jaj；
将区间 [k+1,n)[k+1, n)[k+1,n) 反转，得到下一个字典序排列。

prev_permutation 将上述比较方向反过来即可。对应实现如下：

1
#include <iostream>
2
using namespace std;
3

4
void swap(int *a, int *b) {
5
    *a ^= *b;
6
    *b ^= *a;
7
    *a ^= *b;
8
}
9

10
int main() {
11
    int n;
12
    cin >> n;
13
    int a[n];
14
    for (int i = 0; i < n; ++i) {
15
        a[i] = i + 1;
16
    }
17
    while (true) {
18
        for (int i = 0; i < n; i++) {
19
            cout << a[i] << ' ';
20
        }
21
        cout << endl;
22

23
        int k = n - 2;
24
        int j = n - 1;
25
        // prev_permutation：把 >= 改成 <=
26
        for (; k >= 0 && a[k] >= a[k + 1]; --k) {}
27
        if (k == -1) {
28
            break;
29
        }
30
        for (; j > k && a[k] >= a[j]; --j) {}
31
        swap(&a[j], &a[k]);
32
        for (int i = 0; i < (n - 1 - k) / 2; ++i) {
33
            swap(&a[k + 1 + i], &a[n - 1 - i]);
34
        }
35
    }
36
    return 0;
37
}

展开收起

单次 next_permutation 为 O(n)O(n)O(n)，枚举全部为 O(n⋅n!)O(n \cdot n!)O(n⋅n!)，额外空间 O(1)O(1)O(1)（原地）。

5. Steinhaus–Johnson–Trotter（SJT）算法#

SJT 又称最小改动排列生成算法，其通过相邻交换依次得到下一个排列：为每个元素维护移动方向；每次找出可合法移动的最大元素，与其方向上的相邻元素交换，并翻转所有更大元素的方向，直到没有元素可移动。其具体实现如下：

1
#include <iostream>
2
using namespace std;
3

4
void swap(int &a, int &b) {
5
    a ^= b;
6
    b ^= a;
7
    a ^= b;
8
}
9

10
void print(int a[], int n) {
11
    for (int i = 0; i < n; ++i) {
12
        cout << a[i] << ' ';
13
    }
14
    cout << endl;
15
}
16

17
int main() {
18
    int n;
19
    cin >> n;
20
    int a[n], d[n];
21
    for (int i = 0; i < n; ++i) {
22
        a[i] = i + 1;
23
        d[i] = -1; // -1 向左，+1 向右
24
    }
25
    bool flag = true;
26
    while (flag) {
27
        flag = false;
28
        print(a, n);
29
        int mx = 0;
30
        int max_index = 0;
31
        for (int i = 0; i < n; ++i) {
32
            if ((d[i] < 0 && i > 0 && a[i] > a[i - 1]) ||
33
                (d[i] > 0 && i < n - 1 && a[i] > a[i + 1])) {
34
                if (a[i] > mx) {
35
                    mx = a[i];
36
                    max_index = i;
37
                    flag = true;
38
                }
39
            }
40
        }
41
        if (!flag) {
42
            break;
43
        }
44
        swap(a[max_index], a[max_index + d[max_index]]);
45
        swap(d[max_index], d[max_index + d[max_index]]);
46
        for (int i = 0; i < n; ++i) {
47
            if (a[i] > mx) {
48
                d[i] = -d[i];
49
            }
50
        }
51
    }
52
    return 0;
53
}

展开收起

IMPORTANT

初始为字典序时，SJT 的生成顺序通常也不是字典序。时间 O(n⋅n!)O(n \cdot n!)O(n⋅n!)，空间 O(n)O(n)O(n)（含方向数组）。

应用：填数问题#

全排列本质是穷举。若必须枚举全部排列，时间至少 O(n⋅n!)O(n \cdot n!)O(n⋅n!)，只适合规模较小的问题。在解题经验上，时限约 1000 ms1000\,\mathrm{ms}1000ms、O(n!)O(n!)O(n!) 量级时，n≤11n \leq 11n≤11 是一般而言可行的规模上限；若剪枝得当有时 nnn 可到 121212 或 131313。

例题： 2016 年第七届蓝桥杯省赛 C 语言 A 组第 3 题——在如下十格填入 000–999（各用一次），要求任意两个连续整数（差的绝对值为 111）所在格不能相邻（含斜向）。

该问题本质是图上的约束计数，一般用 DFS 来解决。但考虑到本题的规模，也可先求全排列，再通过特殊的判定条件筛选出满足条件的排列。下面用字典序法枚举所有排列并逐个判断是否满足条件。

1
#include <iostream>
2
#define n 10
3
#define abs(a) ((a) > 0 ? (a) : -(a))
4
using namespace std;
5

6
void swap(int *a, int *b) {
7
    *a ^= *b;
8
    *b ^= *a;
9
    *a ^= *b;
10
}
11

12
int main() {
13
    int *a = new int[n];
14
    for (int i = 0; i < n; ++i) {
15
        a[i] = i;
16
    }
17
    int count = 0;
18
    while (true) {
19
        if (abs(a[0] - a[1]) != 1 && abs(a[1] - a[2]) != 1 &&
20
            abs(a[3] - a[4]) != 1 && abs(a[4] - a[5]) != 1 && abs(a[5] - a[6]) != 1 &&
21
            abs(a[7] - a[8]) != 1 && abs(a[8] - a[9]) != 1 &&
22
            abs(a[0] - a[4]) != 1 && abs(a[1] - a[5]) != 1 && abs(a[2] - a[6]) != 1 &&
23
            abs(a[3] - a[7]) != 1 && abs(a[4] - a[8]) != 1 && abs(a[5] - a[9]) != 1 &&
24
            abs(a[0] - a[5]) != 1 && abs(a[1] - a[6]) != 1 &&
25
            abs(a[3] - a[8]) != 1 && abs(a[4] - a[9]) != 1 &&
26
            abs(a[0] - a[3]) != 1 && abs(a[1] - a[4]) != 1 && abs(a[2] - a[5]) != 1 &&
27
            abs(a[4] - a[7]) != 1 && abs(a[5] - a[8]) != 1 && abs(a[6] - a[9]) != 1) {
28
            count++;
29
        }
30
        int k = n - 2, j = n - 1;
31
        for (; k >= 0 && a[k] > a[k + 1]; --k) {}
32
        if (k == -1) {
33
            break;
34
        }
35
        for (; j > k && a[k] > a[j]; --j) {}
36
        swap(&a[j], &a[k]);
37
        for (int i = 0; i < (n - 1 - k) / 2; ++i) {
38
            swap(&a[k + 1 + i], &a[n - 1 - i]);
39
        }
40
    }
41
    cout << count << endl;
42
    delete[] a;
43
    return 0;
44
}

展开收起

答案为 1580。