完整搜尋頁面 →

DLCV 01C・模型壓縮與高效推論

電腦視覺深度學習進階36 分鐘更新於 2026年11月6日

先備知識:DLCV 01A・深度視覺模型的訓練實務、DLCV 01B・網路的積木與組合:分類與影像復原網路

導覽:本頁與本系列: 導覽:本頁與本系列

本頁內容

補充資料 · 6

  1. N:M 半結構化稀疏
  2. 剪枝耦合的通道
  3. 漸進式剪枝排程
  4. 用定點乘數重新量化
  5. 選擇截斷範圍:min-max、百分位數與 MSE
  6. 超越四捨五入:AdaRound、BRECQ 與 LSQ

論文導讀 · 2

  1. The Lottery Ticket Hypothesis(Frankle 與 Carbin,ICLR 2019)
  2. A White Paper on Neural Network Quantization(Nagel 等人,2021)

電腦視覺深度學習

  1. 02 · 深度影像分類
  2. 03 · 物件偵測:從 R-CNN 到 DETR
  3. 09 · 深度影像復原:低階視覺
查看完整課程樹 →

你將學到

  • 區分模型大小、運算量、記憶體流量、延遲與吞吐量。
  • 比較非結構化、結構化與硬體支援的稀疏剪枝。
  • 選擇量化尺度、校準方式,以及 PTQ 或 QAT。
  • 說明蒸餾、低秩分解與高效率架構設計。
  • 檢查任務敏感度,並在目標裝置量測匯出模型。

先看全貌

訓練好的網路,對於某個特定裝置上的某個特定工作,通常比需要的更大、更慢。模型壓縮(model compression)是一組在訓練之後(或訓練期間)移除這些多餘部分的技術,而高效推論(efficient inference)則是讓較小的模型在真實硬體上真的跑得更快的工程。兩者並不相同,這個領域裡大多數的失望都來自把它們混為一談。

為什麼重要。 大部分部署的視覺模型都在預算之下運作(手機相機、每秒 60 張影格的工廠產線、靠電池的機器人),壓縮決定了模型放不放得進這個預算。壓縮也會改變模型:量化或剪枝後的網路是另一個函數,可能在原本不會出錯的地方出錯。因此整章只有一條規則:在目標裝置上量測成本,並在部署資料上量測壓縮後的準確率。

基礎知識在哪裡。 本章建立在站內其他地方教過的內容上,並以連結取代重複:計算 FLOPs、記憶體帳、延遲協定、仿射量化公式與匯出執行環境,見 ML 11;帶溫度的 logit 蒸餾損失與經過測試的梯度檢查,見 DLCV 01 補充資料;深度可分離卷積與區塊成本,見 DLCV 02 與 DLCV 01B;偵測器的速度量測,見 DLCV 03A。這裡所有程式碼都只用 NumPy 與 scikit-learn,在 CPU 上幾秒就跑完,並使用 scikit-learn 內建的 digits 資料集或合成資料。我們程式碼產生的每一個準確率數字都是玩具結果,來自 8 × 8 像素的數字辨識任務;它說明的是一個機制,而不是真實視覺模型上效果的大小。

下表是本章的地圖。

技術縮小什麼需要什麼速度可能從哪裡來
非結構化剪枝非零權重的數量微調;要稀疏核才跑得快稀疏核,或受限於記憶體時的壓縮儲存
結構化剪枝通道、注意力頭、區塊微調較小的稠密張量:任何執行環境都適用
量化每個權重與激活值的位元數校準資料,或量化感知訓練整數或低精度核;搬動的位元組更少
蒸餾架構(較小的學生)一個教師與一次訓練學生在設計上就比較小
低秩分解把一個大層拆成兩個細層通常需要微調乘加運算更少,前提是細層能有效率地執行
高效設計與搜尋架構本身搜尋或設計預算依硬體挑選的區塊

「成本」是什麼意思

白話版。 壓縮前先確定受限資源:儲存空間、執行記憶體、延遲或吞吐量。參數或運算較少,不保證推論較快。

六個彼此不同的數字

描述執行一個網路要花多少成本的有六個數字:

  • 參數量 PP:學習到的值的數量。每個值用 bb 位元時,權重在磁碟與記憶體中占 P b/8P\,b/8 位元組。剪枝與量化都會降低這個數字。
  • 乘加運算(multiply–accumulate, MAC)或 FLOPs:每張影像的運算量。一次 MAC 是一次乘法加一次加法,通常算作 2 FLOPs;各函式庫的計算方式不一致,所以要寫明你回報的是哪一種。一個從 CinC_{\text{in}} 個通道到 CoutC_{\text{out}} 個通道、輸出為 H′×W′H' \times W' 的 k×kk \times k 卷積,成本是 k2CinCoutH′W′k^2 C_{\text{in}} C_{\text{out}} H' W' 次 MAC(ML 11)。
  • 記憶體流量(memory traffic):在主記憶體與運算單元之間搬動的位元組數。權重、輸入激活值與輸出激活值,至少都要被讀取或寫入一次。
  • 尖峰記憶體(peak memory):一次前向傳遞中,同一時間存在的最大記憶體量(權重加上仍需要的激活值)。對高解析度的影像復原網路而言,它可能由激活值而不是權重主導。
  • 延遲(latency):在目標裝置上,一個輸入從頭到尾的實際經過時間。相機管線或使用者感受到的就是這個。
  • 吞吐量(throughput):許多影像一起處理時,每秒處理的影像數。大批次會提高吞吐量,但不會降低單張影像的延遲。

Dehghani 等人指出,這些成本指標可能互相矛盾,只回報其中一個,可能會對哪個模型比較有效率得出錯誤的結論 [1]。壓縮會讓這種不一致更嚴重,因為每種技術攻擊的是不同的數字:剪枝針對參數量與 MAC,量化針對位元組,而兩者都不會自動針對延遲。

運算強度與屋頂線

白話版。 層的速度可能受運算或記憶體存取限制;若瓶頸是資料搬移,減少計算的幫助有限。

精確版。 Williams、Waterman 與 Patterson 的屋頂線模型(roofline model)[2] 用下式限制一個計算可達到的速度:

attainable speed=min⁡(π,  β⋅I),I=operationsbytes moved,\text{attainable speed} = \min\bigl(\pi,\; \beta \cdot I\bigr), \qquad I = \frac{\text{operations}}{\text{bytes moved}},

其中 π\pi 是裝置的尖峰運算速率(這裡以每秒 MAC 數計)、β\beta 是它的記憶體頻寬(每秒位元組數),II 是該計算的運算強度(arithmetic intensity,每位元組的 MAC 數)。兩個上限交會處的強度 I∗=π/βI^\ast = \pi / \beta 稱為脊點(ridge point):低於它時,該層受限於記憶體(memory-bound),高於它時則受限於運算(compute-bound)。單一層的簡單時間估計是

t≈max⁡ ⁣(MACsπ,  bytesβ).t \approx \max\!\left(\frac{\text{MACs}}{\pi},\; \frac{\text{bytes}}{\beta}\right).

下面的程式碼把這個式子套用到一個虛構的加速器(4 TMAC/s、100 GB/s;真實裝置各不相同)上的幾個層,並假設每個權重、輸入與輸出值恰好各穿過記憶體一次。真實的核會重複利用快取並讓資料傳輸與運算重疊,所以這些數字只是理想化的示意。

程式碼 · Python · 25 行
# A made-up accelerator: 4 TMAC/s peak compute, 100 GB/s memory bandwidth.
PEAK_MACS, BANDWIDTH = 4e12, 100e9

def layer(kind, C=64, H=56, W=56, batch=1):
    """MACs and bytes moved, if weights, inputs and outputs each cross memory once."""
    if kind == "conv 3x3":
        weights, macs = 9 * C * C, 9 * C * C * H * W
    elif kind == "depthwise 3x3":
        weights, macs = 9 * C, 9 * C * H * W
    elif kind == "pointwise 1x1":
        weights, macs = C * C, C * C * H * W
    elif kind == "linear 2048x2048":
        weights, macs, C, H, W = 2048 * 2048, 2048 * 2048, 2048, 1, 1
    acts = 2 * C * H * W                                  # one input and one output tensor
    return batch * macs, weights + batch * acts

for kind, batch, nbytes in [("conv 3x3", 1, 4), ("depthwise 3x3", 1, 4), ("pointwise 1x1", 1, 4),
                            ("depthwise 3x3", 1, 1), ("linear 2048x2048", 1, 4), ("linear 2048x2048", 64, 4)]:
    macs, values = layer(kind, batch=batch)
    traffic = values * nbytes
    t_compute, t_memory = macs / PEAK_MACS, traffic / BANDWIDTH
    bound = "compute" if t_compute > t_memory else "memory"
    print(f"{kind:17s} batch {batch:2d} {8 * nbytes:2d}-bit: {macs / 1e6:7.1f} M MACs, "
          f"{macs / traffic:5.1f} MACs/byte, ~{max(t_compute, t_memory) * 1e6:6.1f} us ({bound}-bound)")
print(f"ridge point: {PEAK_MACS / BANDWIDTH:.0f} MACs/byte")

輸出:

程式碼 · 7 行
conv 3x3          batch  1 32-bit:   115.6 M MACs,  65.9 MACs/byte, ~  28.9 us (compute-bound)
depthwise 3x3     batch  1 32-bit:     1.8 M MACs,   1.1 MACs/byte, ~  16.1 us (memory-bound)
pointwise 1x1     batch  1 32-bit:    12.8 M MACs,   7.9 MACs/byte, ~  16.2 us (memory-bound)
depthwise 3x3     batch  1  8-bit:     1.8 M MACs,   4.5 MACs/byte, ~   4.0 us (memory-bound)
linear 2048x2048  batch  1 32-bit:     4.2 M MACs,   0.2 MACs/byte, ~ 167.9 us (memory-bound)
linear 2048x2048  batch 64 32-bit:   268.4 M MACs,  15.1 MACs/byte, ~ 178.3 us (memory-bound)
ridge point: 40 MACs/byte
對數–對數圖,橫軸是運算強度(每位元組的 MAC 數),縱軸是可達到的速度(TMAC/s)。一條黑線斜向上升到每位元組 40 MAC,該處以垂直虛線標示為脊點,之後水平維持在 4 TMAC/s。六個點落在線上:批次 1 的線性層約在每位元組 0.25 MAC,fp32 的 3x3 深度卷積約在 1,int8 的 3x3 深度卷積約在 4.5,1x1 卷積約在 8,批次 64 的線性層約在 15,全都在上升的斜線段;約在 66 的 3x3 卷積位於水平段。
圖 1 — 一個虛構加速器的屋頂線,以及程式碼中的各層。脊點左邊的所有層都受限於記憶體流量,所以減少它們的運算幾乎沒有幫助;減少它們的位元組(更少的位元、更大的批次)才會讓它沿著斜線往上移。

後面會反覆出現三個教訓。第一,深度卷積層的 MAC 比稠密的 3×33 \times 3 卷積少 64 倍,估計卻只快了約 1.8 倍,因為它受限於記憶體(這就是 DLCV 01B 中「MAC 不等於延遲」這項警告背後的算術)。第二,把那一層改用 8 位元而不是 32 位元儲存,估計時間縮短為 1/4,而一個 MAC 都沒有變:對受限於記憶體的層,量化的好處來自搬動更少的位元組。第三,批次 64 的線性層做的工作是批次 1 的 64 倍,花的時間卻差不多,因為它的權重只讀一次就重複使用,所以大批次的吞吐量幾乎說明不了批次 1 的延遲。

誠實地量測

請遵循 ML 11 的延遲協定(固定並回報裝置、執行環境、精度、批次大小、解析度與執行緒數;暖機;百分位數;在 GPU 上同步),以及 DLCV 03A 的端到端檢查清單。壓縮另外多了三條自己的規則:

  1. 與公平的稠密基準比較:一個大小相同、用相同預算訓練的稠密模型。Liu 等人發現,在他們檢驗的結構化剪枝方法中,從頭訓練剪枝後的架構,表現持平或優於微調剪枝後的權重 [3];Blalock 等人回顧了 81 篇剪枝論文,發現基準與指標不一致,使大多數比較無從進行 [4]。
  2. 在匯出之後、在你實際出貨的執行環境上量測準確率。 匯出、量化、融合後的計算圖,在數值上是和你訓練的不同的程式。
  3. 回報取捨曲線,而不是單一個點。 在幾種壓縮程度下,準確率對延遲(與記憶體)的曲線,才能顯示一個方法是移動了整條曲線,還是只是在曲線上挑了另一個點。

剪枝

白話版。 剪枝移除選定權重或通道。零散零值需稀疏核心才能加速;移除通道會縮小稠密運算,但延遲仍須實測。

玩具網路第二層 32,768 個權重的兩張直方圖。左:以零為中心的鐘形分布,並在零處有一個尖峰;兩條虛線(約在正負 0.12)之間的中間 80% 以橘色標為移除,兩側尾端以藍色標為保留。右:同一張直方圖以灰色畫出,另有七條細綠色垂直線標示 3 位元的各個格點,間距約 0.17,從負 0.51 到正 0.51,綠色長條顯示落在各格點的權重數;幾乎所有權重都落在中間三個格點。
圖 2 — 兩種壓縮對本章全程使用的玩具 MLP 的一個權重矩陣做了什麼。(a) 量值剪枝移除分布的中間部分。(b) 整個張量共用一個尺度的 3 位元格點:約 62% 的權重捨入成精確的零,99% 落在中間三個格點,所以格點大部分都花在少數大權重上。

移除什麼

把網路的參數寫成向量 θ∈RN\boldsymbol\theta \in \mathbb{R}^{N}。剪枝選擇一個二元遮罩(mask)m∈{0,1}N\mathbf{m} \in \{0, 1\}^{N},並用 m⊙θ\mathbf{m} \odot \boldsymbol\theta 取代 θ\boldsymbol\theta,其中 ⊙\odot 是逐元素相乘。稀疏度(sparsity)是零所占的比例,

s=1−∥m∥0N,s = 1 - \frac{\lVert \mathbf{m} \rVert_0}{N},

其中 ∥m∥0\lVert \mathbf{m} \rVert_0 計算遮罩中非零項的個數。各種方法的差別在於遮罩的粒度:

  • 非結構化(細粒度):任何單一權重都可以被移除。這在選擇移除什麼上有最大的自由度,但結果是一個形狀仍為稠密、卻充滿零星零的張量。Li 等人指出,除非有稀疏卷積函式庫,這種不規則的稀疏並不會大幅降低卷積層的成本 [5]。
  • 結構化(粗粒度):整個濾波器、通道、注意力頭或區塊被移除。移除一個卷積的輸出通道 jj,也會移除下一層的輸入通道 jj,所以兩個張量都縮小,而且仍是稠密的。Li 等人正是因為這個原因,把整個濾波器連同與它相連的特徵圖一起剪掉:結果可以用一般的稠密矩陣函式庫執行 [5]。
  • 半結構化:硬體可以利用的固定小樣式。NVIDIA 的稀疏 Tensor Core 支援 2:4 稀疏,也就是每連續四個權重中至少有兩個零;該論文報告這種樣式的數學吞吐量是稠密單元的兩倍 [6]。

選讀:N:M 半結構化稀疏(見「補充資料」頁)。2:4 的權重如何儲存、訓練—剪枝—重新訓練的流程,以及用 NumPy 檢查這種樣式比非結構化剪枝多損失多少權重量值。

該移除哪些權重:量值與其他準則

最簡單、至今仍最常用的準則是量值(magnitude):移除 ∣θi∣|\theta_i| 最小的權重。它可以逐層套用(每層移除相同比例)或全域套用(整個網路用同一個閾值;小權重多的層因此損失較多)。對結構化剪枝,則改用一組權重的量值:Li 等人用每個濾波器的絕對權重和(ℓ1\ell_1 範數)為濾波器排名 [5]。Network slimming 在訓練時對批次正規化層的尺度因子 γ\gamma 加上 ℓ1\ell_1 懲罰,把不重要通道的尺度推向零,然後移除 ∣γ∣|\gamma| 最小的通道 [7]。還有許多其他準則(以梯度為基礎、二階的、以資料為基礎的);Hoefler 等人對它們做了綜述 [8]。

結構化剪枝有一個非結構化剪枝沒有的陷阱:耦合的通道,例如殘差相加兩側的通道,它們必須一起被移除。Fang 等人的 DepGraph 可以從計算圖自動找出這類群組 [9]。

選讀:剪枝耦合的通道(見「補充資料」頁)。殘差相加、深度層、串接與注意力頭的相依規則,並以小例子逐一走過。

剪枝、微調、再重複

移除權重會改變函數,所以剪枝之後要接著訓練。Han 等人描述了標準的三步驟配方:訓練網路以學出哪些連接重要、剪掉不重要的連接,並重新訓練剩下的權重;他們在 ImageNet 上報告,把 AlexNet 的參數從 6,100 萬降到 670 萬、把 VGG-16 的從 1.38 億降到 1,030 萬,而準確率沒有下降 [10]。他們的 Deep Compression 流程又在剪枝之上加入量化與 Huffman 編碼 [11]。

剪枝常被分成幾個較小的步驟,每一步之後都做一些訓練,而不是一次大幅砍掉。Zhu 與 Gupta 的漸進式排程,在訓練期間把稀疏度從零升到目標值,一開始升得快,接近尾聲時升得慢 [12]。他們也比較了記憶體占用相同的大而稀疏模型與小而稠密模型,發現在他們測試的各種架構上,大而稀疏的模型一致地更準確 [12]。

選讀:漸進式剪枝排程(見「補充資料」頁)。三次方的稀疏度公式與每個符號的定義、一個走過的排程範例,以及它留給你決定的選擇。

程式碼:小型 MLP 的非結構化與結構化剪枝

這段程式碼先在 scikit-learn 的 digits 上訓練一個 64–256–128–10 的 MLP,再用兩種方式剪枝:移除每一層最小的權重,以及移除整個隱藏單元(傳入權重的 ℓ1\ell_1 範數最小者,兩個隱藏層都做)。每個剪枝後的模型都微調 10 個 epoch,並在每一步最佳化器更新之後重新套用遮罩。最後,把剪得最多的結構化模型切成一個真正更小的稠密網路。

程式碼 · Python · 56 行
import copy, warnings
import numpy as np
from sklearn.datasets import load_digits
from sklearn.exceptions import ConvergenceWarning
from sklearn.model_selection import train_test_split
from sklearn.neural_network import MLPClassifier
warnings.filterwarnings("ignore", category=ConvergenceWarning)

X, y = load_digits(return_X_y=True)
Xtr, Xte, ytr, yte = train_test_split(X / 16.0, y, test_size=0.3, random_state=0, stratify=y)
base = MLPClassifier(hidden_layer_sizes=(256, 128), max_iter=300, random_state=0).fit(Xtr, ytr)
print(f"dense: {sum(w.size for w in base.coefs_)} weights, test accuracy {base.score(Xte, yte):.3f}")

def fine_tune(net, masks, epochs=10):
    order_rng = np.random.default_rng(0)
    for _ in range(epochs):
        order = order_rng.permutation(len(Xtr))
        for i in range(0, len(Xtr), 128):
            net.partial_fit(Xtr[order[i:i + 128]], ytr[order[i:i + 128]])   # one Adam step
            for w, m in zip(net.coefs_, masks):
                w *= m                                                     # keep pruned weights at zero

def unstructured_masks(net, sparsity):          # smallest |w| in each layer -> 0
    return [np.abs(w) > np.quantile(np.abs(w), sparsity) for w in net.coefs_]

def structured_masks(net, keep):                # drop hidden units with the smallest L1 norm of incoming weights
    masks = [np.ones_like(w) for w in net.coefs_]
    for l in range(len(net.coefs_) - 1):
        norms = np.abs(net.coefs_[l]).sum(axis=0)
        dead = np.argsort(norms)[: int(round((1 - keep) * norms.size))]
        masks[l][:, dead] = 0                   # incoming weights of the unit ...
        masks[l + 1][dead, :] = 0               # ... and its outgoing weights
    return masks

for name, make, levels in [("remove weights", unstructured_masks, [0.8, 0.9, 0.95]),
                           ("keep units", structured_masks, [0.5, 0.25, 0.125])]:
    for level in levels:
        net = copy.deepcopy(base)
        masks = make(net, level)
        for w, m in zip(net.coefs_, masks):
            w *= m
        before = net.score(Xte, yte)
        fine_tune(net, masks)
        kept = int(sum(m.sum() for m in masks))
        print(f"{name} {level:6.1%}: {kept:5d} weights left, "
              f"accuracy {before:.3f} -> {net.score(Xte, yte):.3f} after fine-tuning")

# The last structured model is a genuinely smaller dense network: slice out the live units.
alive = [masks[l].any(axis=0) for l in range(2)]
small_W = [net.coefs_[0][:, alive[0]], net.coefs_[1][alive[0]][:, alive[1]], net.coefs_[2][alive[1]]]
small_b = [net.intercepts_[0][alive[0]], net.intercepts_[1][alive[1]], net.intercepts_[2]]
h = Xte
for l, (w, b) in enumerate(zip(small_W, small_b)):
    h = h @ w + b if l == 2 else np.maximum(h @ w + b, 0)
print("sliced shapes:", [w.shape for w in small_W],
      "| same predictions:", bool((h.argmax(1) == net.predict(Xte)).all()))

輸出(玩具結果):

程式碼 · 8 行
dense: 50432 weights, test accuracy 0.980
remove weights  80.0%: 10087 weights left, accuracy 0.909 -> 0.974 after fine-tuning
remove weights  90.0%:  5044 weights left, accuracy 0.563 -> 0.954 after fine-tuning
remove weights  95.0%:  2523 weights left, accuracy 0.170 -> 0.885 after fine-tuning
keep units  50.0%: 17024 weights left, accuracy 0.887 -> 0.981 after fine-tuning
keep units  25.0%:  6464 weights left, accuracy 0.550 -> 0.980 after fine-tuning
keep units  12.5%:  2720 weights left, accuracy 0.402 -> 0.957 after fine-tuning
sliced shapes: [(64, 32), (32, 16), (16, 10)] | same predictions: True

從中能讀到什麼。微調做了大部分的工作:移除 90% 的權重會讓準確率掉到 0.563,十個 epoch 就把它帶回 0.954。結構化剪枝產生了一個真正的網路,形狀為 64–32–16–10,任何函式庫都能把它當成一般稠密矩陣來執行。而在剩下約 2,500 個權重時,小的稠密網路(0.957)勝過大的稀疏網路(0.885),這與 Zhu 與 Gupta 在大型模型上的發現相反 [12]:我們的網路對 8 × 8 的數字任務來說參數過多,讓它變窄幾乎沒有代價。不要從這個玩具往任一方向推論。

樂透彩券假說

白話版。 如果剪枝後的網路可以這麼小,為什麼不直接訓練小網路?Frankle 與 Carbin 發現,在他們的實驗中,隨機重新初始化的剪枝網路訓練效果較差,但同一個稀疏網路若重設回它原本的初始權重,訓練效果就和完整網路一樣好。他們提出,大型網路從一開始就含有這種幸運的稀疏子網路(「中獎彩券」,winning tickets)。

這些彩券是用反覆量值剪枝找到的:訓練、剪掉量值最小的權重、把留下的權重重設為初始值,然後重複;在小型 MNIST 與 CIFAR-10 網路上,這個做法一致地找到了只有原本大小 10–20% 或更小的彩券 [13]。在 ImageNet 的規模上,權重必須重設為訓練早期的值,而不是初始化時的值 [14];Liu 等人則報告,在學習率調得好的情況下,他們的實驗中使用彩券初始化並沒有比隨機初始化更好 [3]。實務上的教訓並不誇張:這個假說談的是哪些稀疏網路是可訓練的,而不是更便宜的壓縮方法(找一張彩券要花好幾次完整訓練)。

選讀:樂透彩券假說(Frankle 與 Carbin,ICLR 2019)(見「論文導讀」頁)。實驗控制了什麼、如何讀提早停止的圖,以及這項主張的限制。

量化

白話版。 用 32 位元浮點數訓練的網路,並不需要那麼高的精度才能做出好的預測。量化(quantization)把權重(通常還有激活值)存成小整數(8 位元,有時是 4 位元),並搭配少數幾個尺度因子。這能讓記憶體減少 4 到 8 倍,在有整數運算的硬體上還能加速計算。困難在於,一個小格點必須同時涵蓋大量的小數字與少數非常大的數字。

均勻仿射量化

這是最常見的方案,因為它允許有效率的定點運算 [15],它把實數值 xx 映射成整數 qq,再映射回來 [16]:

q=clip⁡ ⁣(round⁡ ⁣(xs)+z,  qmin⁡,  qmax⁡),x^=s (q−z),q = \operatorname{clip}\!\left(\operatorname{round}\!\left(\frac{x}{s}\right) + z,\; q_{\min},\; q_{\max}\right), \qquad \hat{x} = s\,(q - z),

其中 s>0s > 0 是尺度(scale,相鄰可表示值之間的間距),zz 是整數零點(zero point,精確表示實數 0 的那個整數),[qmin⁡,qmax⁡][q_{\min}, q_{\max}] 是 bb 位元格式的整數範圍(例如無號 8 位元是 [0,255][0, 255],對稱有號格式是 [−127,127][-127, 127]),round⁡\operatorname{round} 是四捨五入到最近的整數,clip⁡\operatorname{clip} 是夾進範圍內,x^\hat{x} 是 xx 經過反量化後的近似值。對於包含 0 的實數範圍 [xmin⁡,xmax⁡][x_{\min}, x_{\max}],常見的選擇是

s=xmax⁡−xmin⁡qmax⁡−qmin⁡,z=qmin⁡−round⁡ ⁣(xmin⁡s).s = \frac{x_{\max} - x_{\min}}{q_{\max} - q_{\min}}, \qquad z = q_{\min} - \operatorname{round}\!\left(\frac{x_{\min}}{s}\right).

對稱量化固定 z=0z = 0 並使用有號範圍。精確表示 0 很重要,因為零填補與 ReLU 的輸出會產生許多精確的零 [15]。會出現兩種誤差:範圍內的值有捨入誤差,最多 s/2s/2;範圍外的值有截斷誤差。範圍越大,截斷越少,但 ss 變大,捨入誤差也隨之變大 [15]。ML 11 有經過測試的實作與誤差對位元數的曲線。

為什麼整數核可以把尺度提到外面

白話版。 只有在一層最昂貴的部分,也就是那一長串乘積之和,能完全用整數執行時,整數才有用。如果每個權重列有一個尺度、每個激活張量有一個尺度,這些尺度就可以從和裡面提出來,只在最後套用一次。

對線性層的一個輸出 yi=∑jWijxjy_i = \sum_j W_{ij} x_j(卷積是對一個區塊做同樣的和),把權重以每個輸出通道一個尺度 sw,is_{w,i} 做對稱量化,Wij≈sw,i qijwW_{ij} \approx s_{w,i}\,q^{w}_{ij},並把輸入以尺度 sxs_x 與零點 zxz_x 做仿射量化,xj≈sx(qjx−zx)x_j \approx s_x (q^{x}_j - z_x)。於是

yi≈sw,i sx∑jqijw (qjx−zx),y_i \approx s_{w,i}\, s_x \sum_{j} q^{w}_{ij}\,\bigl(q^{x}_j - z_x\bigr),

其中的和只涉及整數,並在 32 位元整數暫存器中累加;單一個乘積 sw,isxs_{w,i} s_x 對每個輸出只套用一次。這就是為什麼權重的逐通道尺度很便宜(每個輸出通道一個因子),而激活值的逐通道尺度卻不便宜:它們會落在和的裡面,每個輸入通道都需要重新縮放累加器 [15]。這也是為什麼常見的選擇是對稱的權重加上非對稱的激活值:非對稱的權重零點會為每個輸出加上一個與資料相關的項 [15]。偏置通常保留為 32 位元整數 [16]。

程式碼 · Python · 24 行
import numpy as np

rng = np.random.default_rng(0)
W = rng.normal(0, 0.2, size=(16, 256))              # a layer: 16 outputs, 256 inputs
x = rng.normal(0.3, 1.0, size=256)                  # input activations (not centred at 0)

# Weights: symmetric int8, one scale per output channel (zero point 0).
s_w = np.abs(W).max(axis=1) / 127
W_q = np.round(W / s_w[:, None]).astype(np.int8)

# Activations: affine uint8 with a scale and an integer zero point.
lo, hi = min(x.min(), 0.0), x.max()
s_x = (hi - lo) / 255
z_x = int(np.round(-lo / s_x))
x_q = np.clip(np.round(x / s_x) + z_x, 0, 255).astype(np.uint8)
print("activation scale:", round(s_x, 5), "| zero point:", z_x)

# Integer-only inner products, accumulated in int32, then one rescale per output.
acc = W_q.astype(np.int32) @ (x_q.astype(np.int32) - z_x)
y_int = s_w * s_x * acc
y_ref = W @ x
print("max |integer result - float result|:", np.abs(y_int - y_ref).max().round(4))
print("relative error:", (np.linalg.norm(y_int - y_ref) / np.linalg.norm(y_ref)).round(4))
print("largest |accumulator|:", np.abs(acc).max(), "| int16 limit:", 2**15 - 1)

輸出:

程式碼 · 4 行
activation scale: 0.01967 | zero point: 117
max |integer result - float result|: 0.0495
relative error: 0.0083
largest |accumulator|: 83167 | int16 limit: 32767

整數路徑重現浮點結果,誤差在約 1% 以內。累加器達到 83,167,遠超過 16 位元能容納的範圍,這就是為什麼即使輸入是 8 位元,加速器仍使用 32 位元累加器 [15]。在進入下一層之前,32 位元的結果會用下一層的尺度轉回 8 位元(「重新量化」,requantization)。

選讀:用定點乘數重新量化(見「補充資料」頁)。Jacob 等人如何把合併後的實數尺度變成一次整數乘法加一次位元位移,讓推論時不留下任何浮點運算。

粒度與範圍設定

粒度(granularity)是有多少個值共用一個尺度:每個張量一個、每個輸出通道一個,或每一小組連續權重一個。粒度越細,格點越能貼合每一組自己的範圍。範圍設定(range setting,也稱校準)是 [xmin⁡,xmax⁡][x_{\min}, x_{\max}] 的選擇方式 [15]:

  • Min-max:觀察到的最小值與最大值。沒有截斷,但一個離群值就會把所有人的格點拉寬。
  • 百分位數:忽略一小部分最極端的值。
  • MSE:在具代表性的資料上,搜尋使 ∥x−x^∥2\lVert x - \hat{x} \rVert^2 最小的範圍,在截斷與捨入之間取捨。

權重事先已知,不需要資料。激活值取決於輸入,所以它們的範圍是靠讓一小份未標註的校準集(calibration set)影像跑過網路來估計;Nagel 等人指出,500 到 1,000 張未標註影像通常就夠了 [15]。

選讀:選擇截斷範圍:min-max、百分位數與 MSE(見「補充資料」頁)。一個經過測試的比較,顯示最佳規則會隨位元寬度改變:8 位元時保留離群值,4 位元時截斷它們。

什麼會壞掉:離群值、折疊後的批次正規化與激活值

白話版。 當一個共用的尺度必須涵蓋大小差異極大的值時,量化就會失敗。大的值迫使格點變粗,而大量的小值全都被捨入到少數幾個整數。

典型的視覺例子是 MobileNetV2。Nagel 等人指出,它的一個深度可分離層中,不同輸出通道的權重範圍差異極大,以致一組量化參數無法服務整個張量;在折疊批次正規化並使用 8 位元逐張量量化時,他們的模型在 ImageNet 上的 top-1 準確率從 71.72% 掉到 0.12% [17]。他們的解法不需要資料或訓練:因為 c>0c > 0 時 ReLU⁡(c t)=c ReLU⁡(t)\operatorname{ReLU}(c\,t) = c\,\operatorname{ReLU}(t),所以可以把一層的某個輸出通道縮小,同時把下一層對應的輸入通道放大,函數不會改變(跨層均衡化,cross-layer equalization)。在把 ReLU6 換成具有這個性質的 ReLU 之後,均衡化加上偏置吸收,讓模型在 8 位元下達到 70.92% [17]。

我們的玩具重現了這個機制。我們取訓練好的 MLP,把一個隱藏單元放大 100 倍(並把下一層的權重縮小為 1/100)。浮點網路計算的仍是完全相同的函數,但它的激活值與權重範圍現在含有一個巨大的通道。

程式碼 · Python · 48 行
import warnings
import numpy as np
from sklearn.datasets import load_digits
from sklearn.exceptions import ConvergenceWarning
from sklearn.model_selection import train_test_split
from sklearn.neural_network import MLPClassifier
warnings.filterwarnings("ignore", category=ConvergenceWarning)

X, y = load_digits(return_X_y=True)
Xtr, Xte, ytr, yte = train_test_split(X / 16.0, y, test_size=0.3, random_state=0, stratify=y)
net = MLPClassifier(hidden_layer_sizes=(256, 128), max_iter=300, random_state=0).fit(Xtr, ytr)

def q_weight(w, bits, per_channel):     # symmetric: one scale per output unit, or one per tensor
    qmax = 2 ** (bits - 1) - 1
    m = np.abs(w).max(axis=0, keepdims=True) if per_channel else np.abs(w).max()
    return np.clip(np.round(w * qmax / m), -qmax, qmax) * m / qmax

def q_act(a, hi, bits):                 # post-ReLU activations: grid on [0, hi], zero point 0
    s = hi / (2 ** bits - 1)
    return np.clip(np.round(a / s), 0, 2 ** bits - 1) * s

def run(Ws, bs, X, wbits=None, abits=None, his=None, per_channel=True, record=None):
    h = X
    for l, (w, b) in enumerate(zip(Ws, bs)):
        h = h @ (q_weight(w, wbits, per_channel) if wbits else w) + b
        if l < len(Ws) - 1:
            h = np.maximum(h, 0)
            if record is not None:
                record.append(h)
            if abits:
                h = q_act(h, his[l], abits)
    return h

acc = lambda logits: (logits.argmax(1) == yte).mean()
for c in [1, 100]:
    Ws = [w.copy() for w in net.coefs_]
    bs = [b.copy() for b in net.intercepts_]
    Ws[0][:, 0] *= c; bs[0][0] *= c; Ws[1][0, :] /= c   # same function: ReLU(c*t) = c*ReLU(t)
    calib = []
    run(Ws, bs, Xtr[:100], record=calib)                 # 100 training images calibrate the ranges
    minmax = [a.max() for a in calib]
    pct99 = [np.percentile(a, 99) for a in calib]
    print(f"unit 0 scaled by {c}: float {acc(run(Ws, bs, Xte)):.3f} | "
          f"W8A8 {acc(run(Ws, bs, Xte, 8, 8, minmax)):.3f} | "
          f"W8A4 {acc(run(Ws, bs, Xte, 8, 4, minmax)):.3f} | "
          f"W8A4 clipped {acc(run(Ws, bs, Xte, 8, 4, pct99)):.3f} | "
          f"W4 per-tensor {acc(run(Ws, bs, Xte, 4, per_channel=False)):.3f} | "
          f"W4 per-channel {acc(run(Ws, bs, Xte, 4)):.3f}")

輸出(玩具結果;「W8A4」表示 8 位元權重與 4 位元激活值):

程式碼 · 2 行
unit 0 scaled by 1: float 0.980 | W8A8 0.980 | W8A4 0.978 | W8A4 clipped 0.978 | W4 per-tensor 0.983 | W4 per-channel 0.980
unit 0 scaled by 100: float 0.980 | W8A8 0.980 | W8A4 0.163 | W8A4 clipped 0.980 | W4 per-tensor 0.102 | W4 per-channel 0.978

兩個網路是同一個函數,但有了一個離群通道,4 位元 min-max 的激活值就崩潰到 0.163,4 位元逐張量的權重崩潰到 0.102。把激活值範圍在第 99 百分位數截斷(0.980),以及使用逐單元的權重尺度(0.978),都能解決。這裡截斷剛好不花任何代價;當離群通道攜帶真正的資訊時就會有代價,這就是為什麼會有移動或隔離離群值的方法。

同樣的模式在更大的規模上,推動了 Transformer 的量化研究:Dettmers 等人在大型語言模型中發現系統性的離群特徵維度,並把它們保留在 16 位元 [18],而 SmoothQuant 用等價的逐通道重新縮放,把難度從激活值轉移到權重,與跨層均衡化屬於同一類想法 [19]。

訓練後量化與量化感知訓練

白話版。 你可以只用一點校準資料就量化一個已完成的模型(快、不需要標籤),或者在訓練模型的同時讓它「感受」到捨入,讓它學到能經得起捨入的權重(慢一些,但在低位元寬度下更準確)。

訓練後量化(post-training quantization, PTQ)取一個訓練好的浮點模型,只用一小份校準集來轉換。Nagel 等人建議的流程是:跨層均衡化;對稱的權重量化器與非對稱的激活量化器(若硬體支援,權重逐通道);以 MSE 為基礎的權重範圍;然後在有校準資料時使用 AdaRound(學習每個權重該向上還是向下捨入 [20]),否則使用解析式的偏置校正;最後設定激活值範圍 [15]。

量化感知訓練(quantization-aware training, QAT)在前向傳遞中插入「偽量化」(先量化、再立刻反量化),並照常訓練。困難在於 round⁡\operatorname{round} 幾乎處處梯度為零。直通估計器(straight-through estimator, STE)[21] 在反向傳遞中把捨入視為恆等映射。對於對稱量化器 x^=s clip⁡(round⁡(x/s),qmin⁡,qmax⁡)\hat{x} = s\,\operatorname{clip}(\operatorname{round}(x/s), q_{\min}, q_{\max}),這給出

∂x^∂x≈{1,qmin⁡≤x/s≤qmax⁡,0,otherwise,\frac{\partial \hat{x}}{\partial x} \approx \begin{cases} 1, & q_{\min} \le x/s \le q_{\max},\\ 0, & \text{otherwise}, \end{cases}

所以梯度會原封不動地通過範圍內的值,並在被截斷的值處停止 [15]。被更新的是浮點的「影子」權重,而前向傳遞永遠使用它們量化後的版本。

何時用哪一種:在白皮書的實驗中,PTQ 足以處理 8 位元的權重與激活值(所有測試的模型都在浮點結果的 0.7% 以內),而更低的位元寬度,特別是 4 位元激活值,就需要 QAT;使用深度可分離層的網路,即使做了 QAT 仍然是最難的 [15]。

選讀:超越四捨五入:AdaRound、BRECQ 與 LSQ(見「補充資料」頁)。三項改進:學習每個權重該向上或向下捨入、重建整個區塊,以及在 QAT 中學習尺度本身。

混合精度與其他數字格式

並非所有層都同樣敏感,所以混合精度量化(mixed-precision quantization)讓不同的層使用不同的位元寬度:HAWQ 根據二階(Hessian)資訊選擇 [22],HAQ 則根據硬體模擬器回饋的延遲與能耗,並發現邊緣與雲端加速器的最佳策略並不相同 [23]。整數不是唯一的選擇:8 位元浮點編碼(E4M3 與 E5M2)[24] 把位元花在指數上,能容忍更寬的數量級範圍,代價是步階更少。

不要把這和混合精度訓練(DLCV 01A)混淆,後者保留一份 32 位元的權重主副本,並用 16 位元計算以加快訓練。混合精度量化談的是部署後的模型。

知識蒸餾

白話版。 訓練一個小的學生(student)去模仿大的教師(teacher),而不只是模仿正確的標籤。教師的完整輸出(它認為哪些錯誤類別也有可能)以及它的中間特徵,每個範例帶有的資訊比一個標籤更多,所以學生從同樣的影像可以學到更多。

Hinton 等人帶溫度 TT 與 T2T^2 因子的回應式損失,已在 DLCV 01 補充資料中推導並測試,並在 ML 11 中摘要 [25];這裡不重複。用一行來說:學生最小化 (1−α) CE(y,σ(z))+α T2 CE(σ(v/T),σ(z/T))(1-\alpha)\,\mathrm{CE}(y, \sigma(\mathbf{z})) + \alpha\,T^2\,\mathrm{CE}(\sigma(\mathbf{v}/T), \sigma(\mathbf{z}/T)),其中 z\mathbf{z} 與 v\mathbf{v} 分別是學生與教師的 logits,yy 是標籤,σ\sigma 是 softmax,CE\mathrm{CE} 是交叉熵,α∈[0,1]\alpha \in [0, 1] 是軟項的權重。Hinton 等人指出,像 Ba 與 Caruana 那樣用 L2 損失迴歸 logits 來匹配它們 [26],是這個損失在高溫下的極限 [25]。

程式碼:把玩具 MLP 蒸餾成 8 單元的學生

教師是剪枝程式碼中那個有 50,432 個權重的 MLP。學生只有一個含 8 個單元的隱藏層(592 個權重),用全批次梯度下降訓練:一次只用標籤,兩次使用蒸餾損失。

程式碼 · Python · 43 行
import warnings
import numpy as np
from sklearn.datasets import load_digits
from sklearn.exceptions import ConvergenceWarning
from sklearn.model_selection import train_test_split
from sklearn.neural_network import MLPClassifier
warnings.filterwarnings("ignore", category=ConvergenceWarning)

X, y = load_digits(return_X_y=True)
Xtr, Xte, ytr, yte = train_test_split(X / 16.0, y, test_size=0.3, random_state=0, stratify=y)
teacher = MLPClassifier(hidden_layer_sizes=(256, 128), max_iter=300, random_state=0).fit(Xtr, ytr)
h = Xtr
for l, (w, b) in enumerate(zip(teacher.coefs_, teacher.intercepts_)):   # teacher logits
    h = h @ w + b if l == 2 else np.maximum(h @ w + b, 0)
z_teacher = h

def softmax(z, T=1.0):
    e = np.exp((z - z.max(axis=1, keepdims=True)) / T)
    return e / e.sum(axis=1, keepdims=True)

def train_student(T, alpha, hidden=8, steps=500, lr=0.2, seed=0):
    """64 -> 8 -> 10 ReLU network, full-batch gradient descent on the distillation loss."""
    rng = np.random.default_rng(seed)
    W1, b1 = rng.normal(0, np.sqrt(2 / 64), (64, hidden)), np.zeros(hidden)
    W2, b2 = rng.normal(0, np.sqrt(1 / hidden), (hidden, 10)), np.zeros(10)
    Y, p_T = np.eye(10)[ytr], softmax(z_teacher, T)
    for _ in range(steps):
        a = np.maximum(Xtr @ W1 + b1, 0)
        z = a @ W2 + b2
        # gradient of (1-alpha)*CE(y, softmax(z)) + alpha*T^2*CE(p_T, softmax(z/T)) w.r.t. z
        g = ((1 - alpha) * (softmax(z) - Y) + alpha * T * (softmax(z, T) - p_T)) / len(Xtr)
        ga = (g @ W2.T) * (a > 0)
        W2 -= lr * a.T @ g;  b2 -= lr * g.sum(0)
        W1 -= lr * Xtr.T @ ga; b1 -= lr * ga.sum(0)
    return (np.maximum(Xte @ W1 + b1, 0) @ W2 + b2).argmax(1)

print(f"teacher: {sum(w.size for w in teacher.coefs_)} weights, accuracy {teacher.score(Xte, yte):.3f}")
for T in (1, 4):
    print(f"mean top probability of the teacher on training images at T = {T}: "
          f"{softmax(z_teacher, T).max(axis=1).mean():.3f}")
for name, T, alpha in [("labels only", 1, 0.0), ("distill, T = 1", 1, 0.5), ("distill, T = 4", 4, 0.5)]:
    accs = [(train_student(T, alpha, seed=s) == yte).mean() for s in range(5)]
    print(f"student (592 weights), {name:14s}: accuracy {np.mean(accs):.3f} +/- {np.std(accs):.3f} over 5 seeds")

輸出(玩具結果):

程式碼 · 6 行
teacher: 50432 weights, accuracy 0.980
mean top probability of the teacher on training images at T = 1: 0.998
mean top probability of the teacher on training images at T = 4: 0.787
student (592 weights), labels only   : accuracy 0.936 +/- 0.025 over 5 seeds
student (592 weights), distill, T = 1: accuracy 0.936 +/- 0.025 over 5 seeds
student (592 weights), distill, T = 4: accuracy 0.954 +/- 0.006 over 5 seeds

T=4T = 4 的蒸餾把學生的平均準確率從 0.936 提高到 0.954,並讓它對隨機種子的依賴小得多。T=1T = 1 時則毫無改變,第二行說明了原因:在自己的訓練影像上,教師幾乎是確定的(平均最高機率 0.998),所以它的軟目標實際上就是標籤。溫度才是讓教師對錯誤類別的看法顯現出來的東西。這個效果很小,而且只適用於這個玩具;能遷移的是機制,不是數字。

特徵與注意力蒸餾

教師的中間表示也可以被模仿。FitNets 訓練一個細而深的學生,讓它的某個中間層(「被引導」層)經過一個小的學習式迴歸器(regressor)後,去預測教師的某個中間層(「提示」層);需要迴歸器,是因為兩個層的寬度不同,作者使用卷積迴歸器來讓它的大小保持在可控範圍 [27]。注意力轉移(attention transfer)模仿的是教師的特徵在哪裡活躍,而不是特徵本身:對特徵圖 A∈RC×H×WA \in \mathbb{R}^{C \times H \times W},它形成一張空間圖

F(A)=∑c=1C∣Ac∣p,F(A) = \sum_{c=1}^{C} \lvert A_c \rvert^{p},

其中 AcA_c 是通道 cc,p≥1p \ge 1 是指數(該論文也研究了 p=1p = 1 以及對通道取最大值),並訓練學生在多個深度上匹配教師經 ℓ2\ell_2 正規化的圖 [28]。因為 F(A)F(A) 沒有通道維度,教師與學生的寬度不需要一致。Gou 等人依傳遞的內容(回應、特徵、範例之間或層之間的關係)以及傳遞的方式(從固定教師離線、線上,或自蒸餾)來整理這個領域 [29]。

蒸餾有沒有用,取決於什麼

  • 教師與學生必須看到相同的輸入。 Beyer 等人發現,當教師與學生拿到每張影像完全相同的擴增視角(「一致」的教學)、擴增很強,並且訓練時間很長(「有耐心」)時,蒸餾效果最好;不一致的設定在他們的實驗中停在較低的水準 [30]。
  • 更好的教師不一定是更好的老師。 Cho 與 Hariharan 發現,更大、更準確的教師往往沒有產生更好的學生,他們把原因歸於容量不匹配,發現經由中等大小模型的多步蒸餾無效,並報告提早停止教師的訓練可以緩解這個問題 [31]。
  • 蒸餾是一種訓練方法,不是對既有模型的壓縮:它需要一次訓練、資料,以及事先選定的學生架構。例如 DeiT 訓練視覺 Transformer 時,加了一個向卷積教師學習的蒸餾 token(DLCV 02)[32]。

低秩分解

白話版。 一個大的權重矩陣所含的資訊,往往比它的大小所暗示的少得多。把它寫成兩個細矩陣的乘積,就能把一個大層換成兩個小層,權重與運算都少很多。

任何 m×nm \times n 矩陣 WW 都有奇異值分解 W=UΣV⊤W = U \Sigma V^\top,其中 UU(m×mm \times m)與 VV(n×nn \times n)的各行互相正交且長度為 1,Σ\Sigma 是對角矩陣,對角線上是奇異值 σ1≥σ2≥⋯≥0\sigma_1 \ge \sigma_2 \ge \dots \ge 0。保留最大的 rr 個,就得到 Frobenius 範數下最佳的秩-rr 近似(ML 01A):

W≈AB,A=U:,1:r Σ1:r,1:r∈Rm×r,B=V:,1:r⊤∈Rr×n,W \approx A B, \qquad A = U_{:, 1:r}\,\Sigma_{1:r,1:r} \in \mathbb{R}^{m \times r}, \qquad B = V_{:, 1:r}^\top \in \mathbb{R}^{r \times n},

其中 U:,1:rU_{:,1:r} 是 UU 的前 rr 行,rr 是選定的秩(rank)。層 x↦Wxx \mapsto W x 變成兩層 x↦A(Bx)x \mapsto A(Bx),權重數為 r(m+n)r(m + n) 而不是 mnmn,只有當 r<mn/(m+n)r \lt mn/(m+n) 時才會節省權重與 MAC。對於核為 W∈RCout×Cin×k×kW \in \mathbb{R}^{C_{\text{out}} \times C_{\text{in}} \times k \times k} 的卷積,把它重塑成 Cout×(Cink2)C_{\text{out}} \times (C_{\text{in}} k^2) 的矩陣再分解:BB 變成有 rr 個輸出通道的 k×kk \times k 卷積,AA 是回到 CoutC_{\text{out}} 個通道的 1×11 \times 1 卷積。Denton 等人利用卷積濾波器中這類線性結構,在 CPU 與 GPU 上把卷積層加速約兩倍,準確率差距在 1% 以內 [33];Jaderberg 等人建立了在空間域中秩為 1 的濾波器基底(一個 k×1k \times 1 後接一個 1×k1 \times k 的濾波器)[34];Zhang 等人把低秩加速擴展到用於分類與偵測的非常深的網路,其最小化的是每層非線性響應的重建誤差,而不是權重的重建誤差 [35]。

程式碼 · Python · 21 行
import warnings
import numpy as np
from sklearn.datasets import load_digits
from sklearn.exceptions import ConvergenceWarning
from sklearn.model_selection import train_test_split
from sklearn.neural_network import MLPClassifier
warnings.filterwarnings("ignore", category=ConvergenceWarning)

X, y = load_digits(return_X_y=True)
Xtr, Xte, ytr, yte = train_test_split(X / 16.0, y, test_size=0.3, random_state=0, stratify=y)
net = MLPClassifier(hidden_layer_sizes=(256, 128), max_iter=300, random_state=0).fit(Xtr, ytr)
(W1, W2, W3), (b1, b2, b3) = net.coefs_, net.intercepts_

U, S, Vt = np.linalg.svd(W2, full_matrices=False)       # W2 is 256 x 128
energy = np.cumsum(S**2) / np.sum(S**2)
for r in [4, 8, 16, 32, 128]:
    A, B = U[:, :r] * S[:r], Vt[:r]                     # W2 ~ A @ B: a 256->r and an r->128 layer
    h = np.maximum(np.maximum(Xte @ W1 + b1, 0) @ A @ B + b2, 0)
    acc = ((h @ W3 + b3).argmax(1) == yte).mean()
    print(f"rank {r:3d}: {A.size + B.size:5d} weights instead of {W2.size} "
          f"({energy[r - 1]:.0%} of the squared singular values), accuracy {acc:.3f}")

輸出(玩具結果):

程式碼 · 5 行
rank   4:  1536 weights instead of 32768 (29% of the squared singular values), accuracy 0.620
rank   8:  3072 weights instead of 32768 (47% of the squared singular values), accuracy 0.978
rank  16:  6144 weights instead of 32768 (58% of the squared singular values), accuracy 0.981
rank  32: 12288 weights instead of 32768 (72% of the squared singular values), accuracy 0.981
rank 128: 49152 weights instead of 32768 (100% of the squared singular values), accuracy 0.980

秩 8 保留了準確率,所用的權重不到該層的十分之一,儘管它只保留了 47% 的奇異值平方。權重的 Frobenius 誤差並不是任務誤差的好指標:重要的是這一層對它實際看到的輸入做了什麼,這就是 Zhang 等人改為最小化響應誤差的原因 [35]。最後一行顯示了損益兩平規則:滿秩時分解後的形式權重比原本更多,因為 128>256⋅128/384≈85128 > 256 \cdot 128 / 384 \approx 85。把一層拆成兩層,還會為中間結果多出一次記憶體往返,所以在受限於記憶體的裝置上,延遲的節省會比 MAC 的節省小。

三個玩具並排看

玩具 MLP 測試準確率的三張折線圖。(a) 準確率對保留權重百分比(對數軸,從 2 到 50):不微調的量值剪枝(藍)從 50% 時的 0.97 掉到 2% 時的約 0.1;有微調的(橘)在 10% 以前都維持在 0.98 附近,到 2% 掉到 0.37;移除整個單元並微調的(綠)在約 8% 以前維持在 0.98,在 2.4% 時是 0.89。(b) 準確率對權重位元數(2 到 8):逐張量(黃)從 3 位元起約為 0.98,在 2 位元掉到約 0.1;逐通道(粉紅)從 3 位元起約為 0.98,2 位元時是 0.85。(c) 準確率對第二層的秩(對數軸,從 1 到 64)急遽上升,在秩 8 時達到 0.98,而奇異值平方所占的比例(虛線)緩慢上升,在秩 64 時是 0.89。
圖 3 — 同一個網路上的三種玩具壓縮(單一種子;玩具結果)。(a) 微調救回了剪枝,而且在這個參數過多的玩具上,移除整個單元撐得最好。(b) 權重可以撐到 3 位元;在 2 位元時,只有逐通道尺度能讓模型保持可用。(c) 準確率在秩 8 就飽和了,遠早於權重近似變好的時候。

一開始就設計得小

白話版。 與其在訓練後縮小一個大網路,你可以從一開始就選擇小而且對硬體友善的架構,不論是手工設計(高效率區塊)還是靠搜尋。實務上兩種做法會結合:設計良好的小網路再做量化,有時也做剪枝或蒸餾。

主要的手工設計家族在別處已經涵蓋,這裡只列出:深度可分離卷積與反向殘差(MobileNet [36]、MobileNetV2 [37];推導與成本見 DLCV 02 與 ML 03)、深度/寬度/解析度的複合縮放(EfficientNet [38];DLCV 02),以及逐區塊的成本算術(DLCV 01B)。本章開頭的屋頂線觀點,是看待這所有家族的正確鏡頭:一個區塊要在某個裝置上有效率,就要對那個裝置而言每位元組做足夠的運算,並且在那裡有快速的核。

重參數化:訓練時豐富,部署時簡單

結構重參數化(structural re-parameterization)訓練一個有數條平行線性分支的區塊,並在部署時把它們合併成一個卷積。RepVGG 訓練的區塊含有一個 3×33 \times 3 卷積、一個 1×11 \times 1 卷積與一條恆等分支,每個後面都接批次正規化,部署時則是由 3×33 \times 3 卷積與 ReLU 組成的簡單堆疊 [39]。折疊的推導與數值檢查,見 DLCV 03A 補充資料;針對增強網路的版本,見 DLCV 09C 補充資料。

重參數化會與量化互相影響。YOLOv6 報告指出,由於大量使用重參數化區塊,先前的 PTQ 技術無法產生好的結果;在它的 1.0 版中,YOLOv6-S 在 8 位元 PTQ 下的 COCO val AP 從 42.4 掉到 35.0,使用 RepOptimizer 訓練後則回到 40.9,因為它縮窄了激活值的分布 [40]。合併後的核加進了範圍差異很大的分支,這正是逐張量量化處理得最差的情況。

神經架構搜尋

白話版。 神經架構搜尋(neural architecture search, NAS)讓演算法選擇層的類型、寬度與核大小,並以準確率來評分候選者,在考慮硬體的形式中,還以目標裝置上量測到的延遲來評分。

Elsken 等人用三項選擇描述每一種 NAS 方法:搜尋空間(允許哪些架構)、搜尋策略(如何提出候選者)與效能估計策略(如何在不完整訓練的情況下為候選者評分)[41]。三個想法對壓縮很重要:

  • 權重共享讓搜尋負擔得起。 最早的強化學習方法是把每個被提出的架構分別訓練 [42];ENAS 讓所有候選者共享同一張大圖的權重 [43],DARTS 把離散的選擇鬆弛成連續的選擇並用梯度下降最佳化 [44],而 Once-for-All 訓練一個網路,從中取出不同深度、寬度、核大小與解析度的子網路給不同的裝置使用,不需要重新訓練 [45]。
  • 針對量測到的延遲搜尋,而不是 FLOPs。 MnasNet 把在真實手機上量測到的延遲放進目標函數 [46];ProxylessNAS 直接在目標任務與硬體上搜尋 [47];FBNet 的可微分搜尋出於同樣的觀察:FLOPs 不一定反映延遲 [48]。
  • 保留一個隨機基準。 Li 與 Talwalkar 發現,在他們使用的兩個基準上,帶提早停止的隨機搜尋至少和 ENAS 一樣好 [49]。

部署:從小模型到快模型

白話版。 壓縮後的模型,要等到編譯器或執行環境把它變成少數幾個大的融合運算,並有支援它的數字格式與稀疏樣式的核,才會變快。論文裡的速度宣稱,常假設了你的裝置沒有的支援。

運算子融合與批次正規化折疊

每個獨立的運算都會從記憶體讀入它的輸入,再把輸出寫回去。運算子融合(operator fusion)把連續的運算(卷積、偏置、批次正規化、激活函數)合併成一個核,讓中間結果留在快速的晶片內記憶體;從屋頂線的觀點來看,它藉由去掉記憶體往返來提高運算強度。最常見的融合是批次正規化折疊(batch-norm folding):推論時,帶有學習到的尺度 γc\gamma_c、平移 βc\beta_c、累積平均 μc\mu_c 與變異數 σc2\sigma_c^2 的批次正規化 [50],對每個輸出通道 cc 是一個仿射映射,所以可以被吸收進前一個卷積,

Wc′=γcσc2+ϵ Wc,bc′=γcσc2+ϵ (bc−μc)+βc,W'_c = \frac{\gamma_c}{\sqrt{\sigma_c^2 + \epsilon}}\,W_c, \qquad b'_c = \frac{\gamma_c}{\sqrt{\sigma_c^2 + \epsilon}}\,(b_c - \mu_c) + \beta_c,

其中 WcW_c 與 bcb_c 是輸出通道 cc 的核與偏置,ϵ\epsilon 是一個很小的常數。經過測試的 NumPy 版本在 DLCV 03A 補充資料。對壓縮而言,請注意因子 γc/σc2+ϵ\gamma_c / \sqrt{\sigma_c^2 + \epsilon}:它在不同通道之間不一樣,所以折疊可能會把各通道的權重範圍拉開,這是 MobileNetV2 難以逐張量量化的原因之一 [17]。在裝置上,批次正規化是在量化之前折疊的,所以整數核看到的是折疊後的權重,而 QAT 必須正確地模擬折疊 [15]。

整數核與執行環境支援

只有當執行環境對計算圖中的每個運算都有整數(或低精度)核時,量化才會加速推論。ML 11 展示了一個純權重 int8 的模型,它小了四倍卻更慢,因為每次呼叫都要把權重轉回浮點。在真實部署中,要檢查:目標是否支援逐通道的權重尺度(不是所有硬體都支援 [15]);哪些運算子退回浮點(每次退回都會多一次反量化與量化);以及執行環境是否讓計算圖在各層之間維持整數。匯出與執行環境工具本身(ONNX、ONNX Runtime、TensorRT、torch.export)在 ML 11 有說明。

為什麼論文的加速在裝置上會縮水

  • FLOPs 不是瓶頸。 一個移除了受限於記憶體的層 90% MAC 的方法,幾乎不會改變它們的時間(圖 1)。
  • 稀疏需要核。 非結構化稀疏,只有在那個裝置上有針對該樣式的稀疏核時才會加速 [5]、[8];2:4 稀疏在部分 GPU 上有專用硬體 [6];結構化剪枝不需要任何特別的東西。
  • 批次大小。 大批次的吞吐量不是批次 1 的延遲(上面的線性層例子)。
  • 管線的其餘部分。 前處理、NMS 這類後處理(DLCV 03A)、縮放與資料傳輸,不會因為網路變小而變小。
  • 不支援的運算子。 單一個沒有低精度核的運算子,就可能迫使加入的轉換比省下的還貴。

壓縮視覺模型:哪些地方敏感

白話版。 視覺模型的不同部分,對壓縮的反應差異很大。每個通道權重很少的層、必須在數值上精確的輸出(框座標、像素值),以及範圍隨影像而變的激活值,是常見的弱點。

分類骨幹

由深度可分離層建成的網路,是最難量化的常見骨幹。在 Nagel 等人的實驗中,使用 4 位元權重與 8 位元激活值時,逐張量 PTQ 讓 MobileNetV2 與 EfficientNet-lite 的 ImageNet top-1 分別損失約 2.5 與 4.2 個點,他們推測原因是深度可分離卷積;逐通道尺度為 EfficientNet-lite 找回了 2.8 個點 [15]。各通道權重範圍差異很大的層,是最先該考慮逐通道尺度或較高精度的候選,而逐層敏感度測試(一次只量化一層並測量下降,如練習 5)可以很快找出其他的層。

偵測器

偵測器預測連續的框座標與分數,兩者都會受粗糙格點之害。在白皮書中,EfficientDet-D1 在浮點下達到 40.08 COCO mAP,8 位元 PTQ 下是 38.29,但 4 位元逐張量權重只有 0.31(逐通道是 35.08);QAT 讓 4 位元權重的結果提高到 35.34 與 36.75 [15]。YOLOv6 這類重參數化的偵測器需要對量化友善的訓練(見上文)[40]。因為嚴格 IoU 下的準確率是粗糙的框座標最先傷到的,所以量化之後要檢查高 IoU 閾值的 AP,而不只是 IoU 0.5 的 AP(DLCV 03A)。

蒸餾對偵測器也需要小心。Wang 等人發現,把一般的蒸餾套用到偵測器只有很小的增益,因此改讓學生在物件附近的位置模仿教師的特徵(位置由錨框估計);這在他們的實驗中改善了 KITTI、Pascal VOC 與 COCO 上的學生 [51]。

密集預測與影像復原

對超解析度、去雜訊與增強而言,輸出是一張影像,每個量化誤差都可能變得看得見。有兩個性質讓這些網路比分類器更難。第一,許多影像復原網路拿掉了批次正規化;Li 等人發現這會讓激活值的動態範圍大得多,破壞了假設激活值已正規化的量化方案,並提出了為每層學習最大值尺度的做法(PAMS)[52]。第二,Hong 等人觀察到,超解析度網路中每個通道的激活值分布都不同,而且還會隨輸入影像改變,並提出逐通道、感知分布的量化(DAQ)[53]。所以要用與部署內容相似的影像做校準(低光源模型就用暗景),用 DLCV 09 的指標在完整解析度下評估,並檢查平滑的漸層,色帶最先出現在那裡。NTIRE 高效率超解析度挑戰賽在固定的 PSNR 閾值下,把執行時間、FLOPs 與參數量分成不同賽道排名 [54](DLCV 09A);DLCV 09C 涵蓋高效率的增強網路。

視覺 Transformer 與擴散模型

在視覺 Transformer 中,softmax 與 GELU 之後的激活值遠非高斯分布,PTQ4ViT 對每個這樣的張量使用兩個範圍來處理 [55];Liu 等人加入一個排序損失,讓量化後的注意力保留注意力分數的順序 [56]。擴散模型多了時間維度:同一個去雜訊網路要在許多雜訊等級下執行,它的激活值分布會隨時間步改變。Q-Diffusion 把這點,連同捷徑層中的雙峰激活值,視為關鍵困難,並使用感知時間步的校準 [57];PTQ4DM 研究的是同一個多時間步校準的問題 [58]。大型分割基礎模型則靠蒸餾來壓縮:MobileSAM 蒸餾 Segment Anything Model [59] 的大型影像編碼器成一個小的(「解耦蒸餾」)[60],EfficientSAM 則預訓練小型編碼器去重建 SAM 的特徵 [61]。

現代觀點

綜述怎麼說

  • 一般壓縮。 Cheng 等人把這個領域分成四類:參數剪枝與量化、低秩分解、轉移式/緊湊卷積濾波器,以及知識蒸餾,並討論每一類的優缺點 [62]。Menghani 把高效深度學習整理成五個領域:壓縮技術、學習技術(如蒸餾)、自動化(超參數最佳化與架構搜尋)、高效架構,以及基礎設施(軟體與硬體),並附上實務者指南 [63]。
  • 量化。 Gholami 等人從基礎(均勻與非均勻量化器、範圍校準、粒度、微調)到進階主題(純整數推論、混合精度、考慮硬體與蒸餾輔助的量化、極低位元量化)綜述量化 [64];Nagel 等人的白皮書是實用的配套,有經過測試的 PTQ 與 QAT 流程以及除錯工作流程 [15]。
  • 剪枝與稀疏。 Hoefler 等人整理了 300 多篇關於推論與訓練稀疏的論文,包括如何在硬體上得到真正的加速 [8]。Cheng、Zhang 與 Shi 依通用或特定加速、何時剪枝、如何剪枝,以及與其他壓縮技術的融合來整理剪枝,並涵蓋大型語言與多模態模型的剪枝 [65]。Blalock 等人仍是剪枝結果該如何回報這件事的警示性參考 [4]。
  • 蒸餾。 Gou 等人依知識類型、訓練方案、教師—學生架構與演算法對蒸餾分類 [29];Wang 與 Yoon 則聚焦於視覺,以及蒸餾為什麼有效 [66]。
  • 架構搜尋。 Elsken 等人提供了上面使用的三維度分類法 [41];White 等人在超過 1,000 篇 NAS 論文之後寫作,給出搜尋空間、演算法與加速技巧的分類法,並附上基準與最佳實務 [67]。

選讀:A White Paper on Neural Network Quantization(Nagel 等人,2021)(見「論文導讀」頁)。它的流程如何建構,以及如何閱讀它的 PTQ 與 QAT 表格。

2023–2026 年的最新進展

  • 超大型模型的低位元權重。 以補償誤差的捨入(GPTQ [68])或感知激活值並保護重要通道(AWQ [69])的方式,把權重量化到 3–4 位元,已成為大型 Transformer 的標準做法;ML 11 介紹了這兩者。SmoothQuant 把離群值從激活值遷移到權重,使語言模型的 8 位元權重與激活值變得可行 [19]。
  • 4 位元的生成式視覺模型。 繼 Q-Diffusion [57] 之後,SVDQuant 把大型擴散模型的權重與激活值都量化到 4 位元:它把激活值的離群值移進權重,再用一個小的高精度低秩分支吸收權重的離群值,並把該分支融合進低位元核,以避免額外的記憶體流量;它結合了本章的兩項技術:低秩分解與量化 [70]。
  • 8 位元浮點格式(E4M3、E5M2),在訓練與推論上作為 int8 的替代方案 [24]。
  • 蒸餾後的基礎模型。 大型視覺基礎模型的小型學生,例如分割用的 MobileSAM 與 EfficientSAM [60]、[61],以及 DLCV 02 討論的蒸餾版 DINOv2 骨幹。
  • 適用於任何計算圖的結構化剪枝。 DepGraph 式的相依分析,讓通道剪枝能用同一個方法套用到 CNN、Transformer 與其他架構 [9]。
  • 由挑戰賽推動的高效影像復原,其中執行時間、FLOPs 與參數量是分開計分的 [54]。

尚未解決的問題

  • 預測裝置速度。 FLOPs 與參數量仍然主導論文,但只有目標裝置上量測到的延遲才重要,而它取決於核、記憶體與批次大小 [1]。
  • 公平的比較。 大小與訓練預算相同的基準、多個種子,以及完整的取捨曲線,仍然常常缺少 [4]、[3]。
  • 低位元激活值。 4 位元權重已越來越常規;4 位元激活值,尤其是在含有深度層、注意力與隨時間變化的分布的網路中,仍然要付出準確率的代價 [15]、[57]。
  • 壓縮在準確率之外改變了什麼。 平均準確率可能掩蓋稀有類別、偏移輸入或校準上的變化;壓縮之後去量測這些,仍不是標準做法。
  • 影像復原與生成模型的壓縮,其誤差在輸出中看得見,而沒有單一指標能完整反映。

重點整理

  • 定義實際部署預算,並在目標裝置量測端到端成本。
  • 減少 MACs 不一定改善記憶體受限層;應檢查搬移位元組數與可用核心。
  • 非結構化剪枝需稀疏運算支援才能加速;結構化剪枝產生較小稠密層,仍須實測。
  • 先試 PTQ,檢查校準與離群值;所需精度造成過大準確率損失時再用 QAT。
  • 蒸餾取決於教師資訊、對應輸入視圖與訓練方式;教師較大不保證較好。
  • 匯出後驗證壓縮模型及敏感輸出,並與同樣充分訓練的小型稠密模型比較。

練習

  1. 屋頂線算術。 在第一段程式碼的虛構加速器(4 TMAC/s、100 GB/s)上,估計一個在 28×2828 \times 28 特徵圖上、128 個輸入與 128 個輸出通道的 3×33 \times 3 卷積,在 16 位元精度下的時間。它是受限於運算還是記憶體?接著找出一個 1024×10241024 \times 1024 的 fp32 線性層要變成受限於運算的最小批次大小。
提示

這個卷積做 9⋅128⋅128⋅784≈115.69 \cdot 128 \cdot 128 \cdot 784 \approx 115.6 M 次 MAC,搬動 147,456+2⋅128⋅784=348,160147{,}456 + 2 \cdot 128 \cdot 784 = 348{,}160 個值,也就是每個值 2 位元組時約 0.70 MB,所以它的強度約為每位元組 166 次 MAC:受限於運算,約 28.9 µs。對批次 BB 的線性層,強度是 B⋅10242/(4 (10242+2048B))B \cdot 1024^2 / \bigl(4\,(1024^2 + 2048 B)\bigr);令它等於 40 得到 B≥233B \ge 233。可以改寫程式碼中的 layer 函式來檢查。

  1. 大而稀疏,還是小而稠密? 在剪枝程式碼中,窄的稠密網路在約 2,500 個權重時勝過稀疏網路,與 Zhu 與 Gupta 在大型模型上的結果不同。設計一個能讓這個比較更公平的玩具實驗(想想每個模型被允許訓練多久、如何初始化),並預測如果原始網路本來就很窄,例如 64–32–16–10,結果會如何改變。
提示

讓兩個模型有相同的最佳化器總步數,分別調整它們的學習率,並加入第三個模型:從頭訓練的窄架構(Liu 等人主張的那種基準)。一個本來就很窄的網路沒有多少冗餘可以移除,所以結構化剪枝應該會更快失去準確率,而能把重要權重保留在任何位置的非結構化模型,可能反而勝出。

  1. 手動量化。 用仿射方案與 min-max 範圍,把數值 −0.8,0,0.3,2.4-0.8, 0, 0.3, 2.4 量化成 4 位元無號整數。計算 ss、zz、每個 qq 與每個 x^\hat{x}。為什麼 −0.8-0.8 的誤差不是零,儘管它就是範圍的一端?誤差有沒有可能大於 s/2s/2?
提示

s=3.2/15≈0.2133s = 3.2/15 \approx 0.2133,z=0−round⁡(−0.8/0.2133)=−round⁡(−3.75)=4z = 0 - \operatorname{round}(-0.8/0.2133) = -\operatorname{round}(-3.75) = 4,所以 q=0,4,5,15q = 0, 4, 5, 15,x^≈−0.853,0,0.213,2.347\hat{x} \approx -0.853, 0, 0.213, 2.347。把 zz 捨入成整數,會讓整個格點平移,使 0 恰好落在格點上;格點因此涵蓋 [−0.853,2.347][-0.853, 2.347] 而不是 [−0.8,2.4][-0.8, 2.4],所以兩個端點值都不在格點上(兩個誤差都約為 0.053,小於 s/2≈0.107s/2 \approx 0.107)。高於 2.347+s/22.347 + s/2 或低於 −0.853−s/2-0.853 - s/2 的值會被截斷,它的誤差就可能超過 s/2s/2。

  1. 蒸餾中的溫度與權重。 用 T∈{2,8}T \in \{2, 8\} 與 α∈{0.5,0.9}\alpha \in \{0.5, 0.9\} 重新執行蒸餾程式碼。哪些設定對 8 單元的學生有幫助?為什麼很高的溫度可能比適中的溫度幫助更小?請在回答中使用軟項的梯度 α T (σ(z/T)−σ(v/T))\alpha\,T\,(\sigma(\mathbf{z}/T) - \sigma(\mathbf{v}/T))。
提示

有一次執行中,T=2T = 2(α=0.5\alpha = 0.5 與 0.90.9)得到 0.948 與 0.953,但 T=8T = 8 得到 0.937 與 0.916,而只用標籤是 0.936。在很高的溫度下,軟目標趨近均勻分布,對正確類別說得更少,而 α=0.9\alpha = 0.9 時標籤項剩下的權重很小;因子 αT\alpha T 也會改變有效的步長,所以學習率會與 TT 互相影響。下結論之前,先拿差異和各種子之間的變異比較。

  1. 逐層敏感度。 用離群值程式碼中的函式 q_weight 與 run,一次只把一層的權重量化到 2 位元(逐通道),其他層保持浮點,並依準確率下降幅度為三層排名。然後只把最穩健的兩層量化到 2 位元,把最敏感的那層保持在 8 位元。這個混合精度模型需要的權重記憶體,與全部 8 位元相比如何?
提示

傳給 run 一串量化與未量化的權重矩陣,而不是使用它的 wbits 參數。三層的權重數分別是 64⋅25664 \cdot 256、256⋅128256 \cdot 128 與 128⋅10128 \cdot 10;記憶體是 ∑ℓPℓ bℓ/8\sum_\ell P_\ell\, b_\ell / 8 位元組,再加上每個輸出單元一個尺度。這就是 HAWQ 這類以敏感度為基礎的混合精度的想法,只是用量測到的準確率取代了 Hessian 資訊。

補充資料

6 則補充資料,各自成頁;主線不依賴它們。

打開補充資料 →

論文導讀

2 篇論文導讀,各自成頁。

打開論文導讀 →

參考文獻

  1. M. Dehghani, A. Arnab, L. Beyer, A. Vaswani and Y. Tay, “The efficiency misnomer,” ICLR, 2022. arXiv
  2. S. Williams, A. Waterman and D. Patterson, “Roofline: an insightful visual performance model for multicore architectures,” Communications of the ACM, vol. 52, no. 4, pp. 65–76, 2009. doi
  3. Z. Liu, M. Sun, T. Zhou, G. Huang and T. Darrell, “Rethinking the value of network pruning,” ICLR, 2019. arXiv
  4. D. Blalock, J. J. Gonzalez Ortiz, J. Frankle and J. Guttag, “What is the state of neural network pruning?,” MLSys, 2020. arXiv
  5. H. Li, A. Kadav, I. Durdanovic, H. Samet and H. P. Graf, “Pruning filters for efficient ConvNets,” ICLR, 2017. arXiv
  6. A. Mishra, J. Albericio Latorre, J. Pool, D. Stosic, D. Stosic, G. Venkatesh, C. Yu and P. Micikevicius, “Accelerating sparse deep neural networks,” arXiv:2104.08378, 2021. arXiv
  7. Z. Liu, J. Li, Z. Shen, G. Huang, S. Yan and C. Zhang, “Learning efficient convolutional networks through network slimming,” ICCV, 2017. arXiv
  8. T. Hoefler, D. Alistarh, T. Ben-Nun, N. Dryden and A. Peste, “Sparsity in deep learning: pruning and growth for efficient inference and training in neural networks,” Journal of Machine Learning Research, vol. 22, no. 241, pp. 1–124, 2021. paper
  9. G. Fang, X. Ma, M. Song, M. B. Mi and X. Wang, “DepGraph: towards any structural pruning,” CVPR, 2023. doi arXiv
  10. S. Han, J. Pool, J. Tran and W. J. Dally, “Learning both weights and connections for efficient neural networks,” NeurIPS (NIPS), 2015. arXiv
  11. S. Han, H. Mao and W. J. Dally, “Deep compression: compressing deep neural networks with pruning, trained quantization and Huffman coding,” ICLR, 2016. arXiv
  12. M. Zhu and S. Gupta, “To prune, or not to prune: exploring the efficacy of pruning for model compression,” arXiv:1710.01878, 2017. arXiv
  13. J. Frankle and M. Carbin, “The lottery ticket hypothesis: finding sparse, trainable neural networks,” ICLR, 2019. arXiv
  14. J. Frankle, G. K. Dziugaite, D. M. Roy and M. Carbin, “Linear mode connectivity and the lottery ticket hypothesis,” ICML, 2020. arXiv
  15. M. Nagel, M. Fournarakis, R. A. Amjad, Y. Bondarenko, M. van Baalen and T. Blankevoort, “A white paper on neural network quantization,” arXiv:2106.08295, 2021. arXiv
  16. B. Jacob, S. Kligys, B. Chen, M. Zhu, M. Tang, A. Howard, H. Adam and D. Kalenichenko, “Quantization and training of neural networks for efficient integer-arithmetic-only inference,” CVPR, 2018. doi arXiv
  17. M. Nagel, M. van Baalen, T. Blankevoort and M. Welling, “Data-free quantization through weight equalization and bias correction,” ICCV, 2019. arXiv
  18. T. Dettmers, M. Lewis, Y. Belkada and L. Zettlemoyer, “LLM.int8(): 8-bit matrix multiplication for transformers at scale,” NeurIPS, 2022. arXiv
  19. G. Xiao, J. Lin, M. Seznec, H. Wu, J. Demouth and S. Han, “SmoothQuant: accurate and efficient post-training quantization for large language models,” ICML, 2023. arXiv
  20. M. Nagel, R. A. Amjad, M. van Baalen, C. Louizos and T. Blankevoort, “Up or down? Adaptive rounding for post-training quantization,” ICML, 2020. arXiv
  21. Y. Bengio, N. Léonard and A. Courville, “Estimating or propagating gradients through stochastic neurons for conditional computation,” arXiv:1308.3432, 2013. arXiv
  22. Z. Dong, Z. Yao, A. Gholami, M. W. Mahoney and K. Keutzer, “HAWQ: Hessian aware quantization of neural networks with mixed-precision,” ICCV, 2019. arXiv
  23. K. Wang, Z. Liu, Y. Lin, J. Lin and S. Han, “HAQ: hardware-aware automated quantization with mixed precision,” CVPR, 2019. arXiv
  24. P. Micikevicius et al., “FP8 formats for deep learning,” arXiv:2209.05433, 2022. arXiv
  25. G. Hinton, O. Vinyals and J. Dean, “Distilling the knowledge in a neural network,” NIPS Deep Learning Workshop, 2014; arXiv:1503.02531. arXiv
  26. L. J. Ba and R. Caruana, “Do deep nets really need to be deep?,” NeurIPS (NIPS), 2014. arXiv
  27. A. Romero, N. Ballas, S. E. Kahou, A. Chassang, C. Gatta and Y. Bengio, “FitNets: hints for thin deep nets,” ICLR, 2015. arXiv
  28. S. Zagoruyko and N. Komodakis, “Paying more attention to attention: improving the performance of convolutional neural networks via attention transfer,” ICLR, 2017. arXiv
  29. J. Gou, B. Yu, S. J. Maybank and D. Tao, “Knowledge distillation: a survey,” International Journal of Computer Vision, vol. 129, no. 6, pp. 1789–1819, 2021. doi
  30. L. Beyer, X. Zhai, A. Royer, L. Markeeva, R. Anil and A. Kolesnikov, “Knowledge distillation: a good teacher is patient and consistent,” CVPR, 2022. arXiv
  31. J. H. Cho and B. Hariharan, “On the efficacy of knowledge distillation,” ICCV, 2019. arXiv
  32. H. Touvron, M. Cord, M. Douze, F. Massa, A. Sablayrolles and H. Jégou, “Training data-efficient image transformers & distillation through attention,” ICML, 2021. arXiv
  33. R. Denton, W. Zaremba, J. Bruna, Y. LeCun and R. Fergus, “Exploiting linear structure within convolutional networks for efficient evaluation,” NeurIPS (NIPS), 2014. arXiv
  34. M. Jaderberg, A. Vedaldi and A. Zisserman, “Speeding up convolutional neural networks with low rank expansions,” BMVC, 2014. arXiv
  35. X. Zhang, J. Zou, K. He and J. Sun, “Accelerating very deep convolutional networks for classification and detection,” IEEE Transactions on Pattern Analysis and Machine Intelligence, vol. 38, no. 10, pp. 1943–1955, 2016. doi arXiv
  36. A. G. Howard, M. Zhu, B. Chen, D. Kalenichenko, W. Wang, T. Weyand, M. Andreetto and H. Adam, “MobileNets: efficient convolutional neural networks for mobile vision applications,” arXiv:1704.04861, 2017. arXiv
  37. M. Sandler, A. Howard, M. Zhu, A. Zhmoginov and L.-C. Chen, “MobileNetV2: inverted residuals and linear bottlenecks,” CVPR, 2018. arXiv
  38. M. Tan and Q. V. Le, “EfficientNet: rethinking model scaling for convolutional neural networks,” ICML, 2019. arXiv
  39. X. Ding, X. Zhang, N. Ma, J. Han, G. Ding and J. Sun, “RepVGG: making VGG-style ConvNets great again,” CVPR, 2021. arXiv
  40. C. Li et al., “YOLOv6: a single-stage object detection framework for industrial applications,” arXiv:2209.02976, 2022. arXiv
  41. T. Elsken, J. H. Metzen and F. Hutter, “Neural architecture search: a survey,” Journal of Machine Learning Research, vol. 20, pp. 1–21, 2019. arXiv
  42. B. Zoph and Q. V. Le, “Neural architecture search with reinforcement learning,” ICLR, 2017. arXiv
  43. H. Pham, M. Y. Guan, B. Zoph, Q. V. Le and J. Dean, “Efficient neural architecture search via parameter sharing,” ICML, 2018. arXiv
  44. H. Liu, K. Simonyan and Y. Yang, “DARTS: differentiable architecture search,” ICLR, 2019. arXiv
  45. H. Cai, C. Gan, T. Wang, Z. Zhang and S. Han, “Once-for-all: train one network and specialize it for efficient deployment,” ICLR, 2020. arXiv
  46. M. Tan, B. Chen, R. Pang, V. Vasudevan, M. Sandler, A. Howard and Q. V. Le, “MnasNet: platform-aware neural architecture search for mobile,” CVPR, 2019. arXiv
  47. H. Cai, L. Zhu and S. Han, “ProxylessNAS: direct neural architecture search on target task and hardware,” ICLR, 2019. arXiv
  48. B. Wu, X. Dai, P. Zhang, Y. Wang, F. Sun, Y. Wu, Y. Tian, P. Vajda, Y. Jia and K. Keutzer, “FBNet: hardware-aware efficient ConvNet design via differentiable neural architecture search,” CVPR, 2019. doi arXiv
  49. L. Li and A. Talwalkar, “Random search and reproducibility for neural architecture search,” UAI, 2019. arXiv
  50. S. Ioffe and C. Szegedy, “Batch normalization: accelerating deep network training by reducing internal covariate shift,” ICML, 2015. arXiv
  51. T. Wang, L. Yuan, X. Zhang and J. Feng, “Distilling object detectors with fine-grained feature imitation,” CVPR, 2019. arXiv
  52. H. Li, C. Yan, S. Lin, X. Zheng, Y. Li, B. Zhang, F. Yang and R. Ji, “PAMS: quantized super-resolution via parameterized max scale,” ECCV, 2020. arXiv
  53. C. Hong, H. Kim, S. Baik, J. Oh and K. M. Lee, “DAQ: channel-wise distribution-aware quantization for deep image super-resolution networks,” WACV, 2022. arXiv
  54. B. Ren, Y. Li, N. Mehta, R. Timofte et al., “The ninth NTIRE 2024 efficient super-resolution challenge report,” CVPR Workshops, 2024. doi arXiv
  55. Z. Yuan, C. Xue, Y. Chen, Q. Wu and G. Sun, “PTQ4ViT: post-training quantization for vision transformers with twin uniform quantization,” ECCV, 2022. doi arXiv
  56. Z. Liu, Y. Wang, K. Han, S. Ma and W. Gao, “Post-training quantization for vision transformer,” NeurIPS, 2021. arXiv
  57. X. Li, Y. Liu, L. Lian, H. Yang, Z. Dong, D. Kang, S. Zhang and K. Keutzer, “Q-Diffusion: quantizing diffusion models,” ICCV, 2023. doi arXiv
  58. Y. Shang, Z. Yuan, B. Xie, B. Wu and Y. Yan, “Post-training quantization on diffusion models,” CVPR, 2023. arXiv
  59. A. Kirillov et al., “Segment anything,” ICCV, 2023. doi arXiv
  60. C. Zhang, D. Han, Y. Qiao, J. U. Kim, S.-H. Bae, S. Lee and C. S. Hong, “Faster segment anything: towards lightweight SAM for mobile applications,” arXiv:2306.14289, 2023. arXiv
  61. Y. Xiong et al., “EfficientSAM: leveraged masked image pretraining for efficient segment anything,” CVPR, 2024. doi arXiv
  62. Y. Cheng, D. Wang, P. Zhou and T. Zhang, “Model compression and acceleration for deep neural networks: the principles, progress, and challenges,” IEEE Signal Processing Magazine, vol. 35, no. 1, pp. 126–136, 2018. doi arXiv
  63. G. Menghani, “Efficient deep learning: a survey on making deep learning models smaller, faster, and better,” ACM Computing Surveys, vol. 55, no. 12, pp. 1–37, 2023. doi arXiv
  64. A. Gholami, S. Kim, Z. Dong, Z. Yao, M. W. Mahoney and K. Keutzer, “A survey of quantization methods for efficient neural network inference,” book chapter in Low-Power Computer Vision; arXiv:2103.13630, 2021. arXiv
  65. H. Cheng, M. Zhang and J. Q. Shi, “A survey on deep neural network pruning: taxonomy, comparison, analysis, and recommendations,” IEEE Transactions on Pattern Analysis and Machine Intelligence, vol. 46, no. 12, pp. 10558–10578, 2024. doi arXiv
  66. L. Wang and K.-J. Yoon, “Knowledge distillation and student-teacher learning for visual intelligence: a review and new outlooks,” IEEE Transactions on Pattern Analysis and Machine Intelligence, vol. 44, no. 6, pp. 3048–3068, 2022. doi arXiv
  67. C. White, M. Safari, R. Sukthanker, B. Ru, T. Elsken, A. Zela, D. Dey and F. Hutter, “Neural architecture search: insights from 1000 papers,” arXiv:2301.08727, 2023. arXiv
  68. E. Frantar, S. Ashkboos, T. Hoefler and D. Alistarh, “GPTQ: accurate post-training quantization for generative pre-trained transformers,” ICLR, 2023. arXiv
  69. J. Lin, J. Tang, H. Tang, S. Yang, W.-M. Chen, W.-C. Wang, G. Xiao, X. Dang, C. Gan and S. Han, “AWQ: activation-aware weight quantization for LLM compression and acceleration,” MLSys, 2024. arXiv
  70. M. Li, Y. Lin, Z. Zhang, T. Cai, X. Li, J. Guo, E. Xie, C. Meng, J.-Y. Zhu and S. Han, “SVDQuant: absorbing outliers by low-rank components for 4-bit diffusion models,” ICLR, 2025. arXiv
  71. Y. Li, R. Gong, X. Tan, Y. Yang, P. Hu, Q. Zhang, F. Yu, W. Wang and S. Gu, “BRECQ: pushing the limit of post-training quantization by block reconstruction,” ICLR, 2021. arXiv
  72. S. K. Esser, J. L. McKinstry, D. Bablani, R. Appuswamy and D. S. Modha, “Learned step size quantization,” ICLR, 2020. arXiv

檢查理解

本篇有 5 題練習。不看提示,你能解出來嗎?

前往練習 ↑

下一篇 DLCV 02・深度影像分類 · 41 分鐘