PyTorch 效能分析(第二部分):從 nn.Linear 到融合式 MLP
Profiling in PyTorch (Part 2): From nn.Linear to a Fused MLP
Hugging Face Blog 第二篇 PyTorch 效能分析教程,從 nn.Linear 追蹤至 GeGLU MLP。
文章對比 eager、torch.compile 與 Liger,展示 MLP 融合如何減少 HBM 往返,以及固定形狀特化與跨形狀通用的取捨。
在《PyTorch 效能分析》系列第一部分中,我們使用 torch.add(torch.matmul(x, w), b) 學習閲讀 PyTorch 分析器追蹤記錄,也討論了幾個相關主題:CPU 分派鏈、啟動開銷、受開銷限制與受運算限制的情況,以及 torch.compile 的一些內部機制。
在第二篇(本文)中,我們再深入一層:以 nn.Linear(設定 bias=True)取代手動編寫的矩陣乘法與加法。這是每個深度學習模型都會用到的基本組件。接着,我們會把三個這類組件堆疊起來(這是本例的特定設定),並在中間加入啟動函數,組成多層感知器(MLP)區塊。
本文的腳本位於:
02_linear.py、03_simple_mlp.py和03_kernels_mlp.py。與之前一樣,建議在另一個分頁開啟這些檔案,邊讀邊查看程式碼。我們使用NVIDIA A100-SXM4-80GBGPU 執行腳本。在 Hugging Face 基礎設施上設定 GPU 十分簡單,你可以使用 Spaces 開發模式執行腳本進行實驗。你也可以使用 Hugging Face Jobs pipeline 執行腳本。
開始之前,先簡短回顧兩個接下來會反覆用到的概念:
- GPU 核心(kernel)是由 GPU 上許多執行緒平行執行的程式。
- CPU 會排程並啟動這些核心。你在分析器追蹤記錄中看到的大部分 PyTorch 開銷,都是這些排程工作。
由矩陣乘法加法改用 Linear
nn.Linear 是包裝模組,內部執行的正是我們在第一部分分析過的矩陣乘法和加法。唯一不同的是,它會把權重和偏置作為參數持有,並提供 PyTorch 使用者熟悉的 forward 方法。
# bias=True would truly emulate the multiplication and addition
# operations we have seen in part 1 of the series
linear_layer = nn.Linear(in_dim, out_dim, bias=True)
y = linear_layer(x)
相關運算可寫成:
y = x @ w.T + b
其中 x 是輸入,w 是權重,b 是偏置。現在執行 02_linear.py,看看分析結果。
uv run 02_linear.py --batch 1024 --in_dim 32 --out_dim 64
uvx trace-util -f traces -b <hf_uname>/traces
trace-util是一個工具,可將追蹤記錄同步至 Hugging Face bucket,然後在終端機提供 Perfetto 網址。
![]() |
|---|
圖 1:nn.Linear 的分析器追蹤記錄 |
圖 1 顯示線性層一次 forward 呼叫的分析器追蹤記錄。我們追蹤線性層的 forward 呼叫,並使用與前面追蹤記錄相近的 schedule 設定:wait=1、warmup=1 和 active=3。因此,CPU 和 GPU 軌道中都會看到 3 個 Profile Step。
轉置有甚麼作用?
![]() |
|---|
| 圖 2:CPU 軌道中的轉置 |
如圖 2 一樣放大分析器追蹤記錄後,會看到一個 aten::t(轉置)運算,接着是 aten::addmm(乘法和加法)運算。由此可知,nn.Linear 會先轉置權重參數,再與輸入相乘,這就是出現 aten::t 運算的原因。
要留意,aten::t 並不會真正複製或重組資料:它只會在 CPU 上改寫張量元資料(形狀和步幅),以表示轉置後的矩陣,也不會在 GPU 上啟動核心。你可以透過兩種方法確認:查看追蹤記錄中的 GPU 軌道,或檢查分析器表格中的 aten::t 列及其 CUDA 執行時間。
為何沒有獨立的 mul 和 add 核心?
![]() |
|---|
圖 3:線性層的分析結果中沒有 aten::add |
如圖 3 所示,線性層的分派鏈中沒有 aten::add(即偏置加法)。原因是偏置加法已折疊至矩陣乘法核心中,這種做法稱為尾聲運算(epilogue)。
尾聲運算是 GEMM(GEneral Matrix Multiply,通用矩陣乘法)核心在最後執行的一小段計算,發生在將結果寫回 HBM(High Bandwidth Memory,即 GPU 主記憶體)之前。加入偏置、套用啟動函數或乘以常數,都是常見的尾聲運算。它的目的,是避免再次從 HBM 讀取或寫入資料,因為記憶體流量會令運算成本增加。
nn.Linear 會呼叫 torch.nn.functional.linear,後者再呼叫 aten::linear。aten::linear 會檢查輸入,發現傳入了偏置後,就會分派至 aten::addmm(bias, x, weight),而非分別執行矩陣乘法和加法。addmm 的計算方式如下:
out = x @ weight.T + bias
在 GPU 上執行的 cuBLAS GEMM 核心內置偏置相加變體,而 aten::addmm 選用的正是這個核心。加法不會以獨立核心出現,因為它已納入矩陣乘法核心的寫回操作,這正是尾聲運算。
現在可以留意一個微妙之處:你在第一部分的 --compile 模式下看到的核心(addmm),正是 eager 模式的 nn.Linear 已在使用的核心。這裏沒有剩下可供 torch.compile 融合的運算,接下來我們會驗證這一點。
--compile 能加速單一 Linear 嗎?
讓我們編譯 forward 呼叫,並查看分析器追蹤記錄。(追蹤記錄會在下一節以圖像呈現。)
uv run 02_linear.py --batch 1024 --in_dim 32 --out_dim 64 --compile
uvx trace-util -f traces -b <hf_uname>/traces
比較單一 nn.Linear 的 forward 在 eager 和編譯模式下的追蹤記錄,會看到:
- GPU 上使用相同的 cuBLAS GEMM 核心。
- CPU 上使用相同的
aten::addmm運算。 - CPU 軌道多了幾列編譯模式專有的項目。
這一點值得記住。模型運行緩慢時,常見的直覺反應是使用 torch.compile。但對單一含偏置的 GEMM 而言,編譯能做的事很少。這不是錯誤,只是編譯需要多於一項運算,才有可能進行融合。讓我們透過查看 MLP來證明這一點。
轉置到哪裏去了?核心佈局與前置運算
仔細比較 eager 和 compile 兩種追蹤記錄,就會發現 eager 模式的 CPU 分派鏈包含的項目較多。
![]() |
|---|
圖 4:Eager 分派鏈中,aten::linear 依次呼叫 aten::t(轉置)和 aten::addmm |
![]() |
|---|
圖 5:編譯模式的分派鏈直接呼叫 aten::addmm,沒有轉置 |
aten::linear 內部的 eager CPU 分派鏈,會先執行 aten::t,再執行 aten::addmm(圖 4)。要了解 aten::t 的實際作用,需要先簡單認識步幅和檢視(view)。
張量會把資料儲存為記憶體中一段連續的數值。shape 和 stride 是這段資料上方的元資料,會告訴 PyTorch 如何讀取:步幅 (s0, s1) 的意思是「移至下一列要跨過 s0 個元素,移至下一欄要跨過 s1 個元素」。改變元資料,就能在不複製資料的情況下,取得相同原始資料的不同檢視:
>>> M = torch.tensor([[0, 1],
... [2, 3],
... [4, 5]])
>>> M.shape, M.stride()
(torch.Size([3, 2]), (2, 1)) # two steps per row, one step per column
>>> T = M.t() # transpose
>>> T.shape, T.stride()
(torch.Size([2, 3]), (1, 2)) # shape and stride swapped, data untouched
>>> T
tensor([[0, 2, 4],
[1, 3, 5]])
>>> T.flatten() # forced to materialize, so the data is reordered
tensor([0, 2, 4, 1, 3, 5])
M.t() 完全沒有移動任何數值。它回傳一個新檢視,並交換步幅,因此逐列讀取時,會以轉置次序走訪原始緩衝區中的 0, 1, 2, 3, 4, 5。底層資料完全相同,只有元資料不同。
這正是線性層中 aten::t 的作用:它不會配置新張量或複製資料,而是產生一個步幅經改寫的權重檢視。
如圖 5 所示,compile 並沒有移除 GPU 核心,而是移除了分派該檢視時的CPU 開銷。Inductor 在編譯時追蹤檢視鏈,只計算一次最終步幅,然後直接產生一個步幅已寫死的 aten::addmm 呼叫。CPU 的數微秒工作消失了,GPU 執行的數學運算則完全相同。
正如預期,如果輸入資料不符合編譯器預先計算的步幅,就會觸發錯誤。
查看兩份追蹤記錄中的 GPU 軌道,每次 forward 都剛好有一個核心,而且兩次都是同一個核心:
cutlass_80_wmma_tensorop_bf16_s161616gemm_bf16_32x32_32x1_tn_align8
如果沒有執行轉置核心,GEMM 是如何讀取轉置次序的權重矩陣?答案就在核心名稱中,看看末尾的後綴:
cutlass_80_wmma_tensorop_bf16_s161616gemm_bf16_32x32_32x1_tn_align8
^^
tn 是佈局描述符。cuBLAS 和 CUTLASS 會為每種輸入佈局組合預先編譯一個獨立的核心二進制檔。
n(不轉置)和 t(轉置)代表核心在內層迴圈中如何走訪輸入。分派器會檢查輸入步幅,判斷哪種後綴組合相符,再選取正確的預編譯核心。
分析器追蹤記錄中的核心名稱,是核心識別資訊的雜湊表示。如果兩次執行顯示相同核心名稱,GPU 執行的工作便相同。如果名稱不同(例如
_tn_與_nn_、bf16與fp16,或s16816gemm與s161616gemm),GPU 執行的工作便不同,表示分派器選了另一個分支。比較追蹤記錄時,學會讀取這些名稱是很有用的習慣。
堆疊三個 Linear:MLP
本節會分析一個多層感知器(MLP)。為了讓內容更有意思,我們會分析採用 GeGLU 啟動變體的前饋網絡(實務上相當常見),也藉此向深度學習研究史上最重要的論述之一致敬(圖 6)。
![]() |
|---|
| 圖 6:《GLU 變體改良 Transformer》論文的結論部分 |
class SimpleGeGLUMLP(nn.Module):
def __init__(self, dim, hidden):
super().__init__()
self.gate_proj = nn.Linear(dim, hidden, bias=False)
self.up_proj = nn.Linear(dim, hidden, bias=False)
self.down_proj = nn.Linear(hidden, dim, bias=False)
def forward(self, x):
g = self.gate_proj(x)
u = self.up_proj(x)
h = F.gelu(g, approximate="tanh")
m = h * u
y = self.down_proj(m)
return y
完整腳本位於此處:03_simple_mlp.py。執行方式如下:
uv run 03_simple_mlp.py --batch 64 --seq 128 --dim 768 --hidden 3072
uvx trace-util -f traces -b <hf_uname>/traces
查看追蹤記錄之前,先一起想想預期會看到甚麼。forward 函數確實執行了不少運算,但大部分都已經很熟悉。
我們預期會有 3 個 aten::linear 分派,分別對應 3 個 nn.Linear 層;也預期會啟動 2 個逐元素運算核心,分別處理 GeLU 和乘法。查看資料前先作出預期,是分析效能過程中最有用的習慣:閲讀追蹤記錄是為了確認或推翻猜測,而不是從零開始猜。
![]() |
|---|
| 圖 7:GeGLU MLP 的分析器追蹤記錄 |
![]() |
|---|
| 圖 8:線性投影 CPU 軌道中標示的 occupancy 查詢 |
從圖 7 可見,我們的直覺正確,值得自我肯定。每次 forward pass(一次 mlp_fwd)中,GPU 剛好執行 5 個核心。圖 8 標示了線性投影層在 CPU 軌道中的「occupancy query」。
| 運算 | CPU 運算 | GPU 核心 | 啟動次數 |
|---|---|---|---|
gate_proj |
aten::linear |
ampere_bf16_s16816gemm_bf16_128x128_... |
occupancy query + cudaLaunchKernel |
up_proj |
aten::linear |
ampere_bf16_s16816gemm_bf16_128x128_... |
occupancy query + cudaLaunchKernel |
gelu |
aten::gelu |
vectorized_elementwise_kernel<4, GeluCUDAKernelImpl...> |
cudaLaunchKernel |
h * u |
aten::mul |
vectorized_elementwise_kernel<4, ...MulFunctor...> |
cudaLaunchKernel |
down_proj |
aten::linear |
ampere_bf16_s16816gemm_bf16_128x256_... |
occupancy query + cudaLaunchKernel |
三個 GEMM 在啟動前都會額外呼叫 cudaOccupancyMaxActiveBlocksPerMultiprocessor。第一部分另有專節在此説明,這是 cuBLAS 用來計算網格大小的步驟。逐元素運算(GeLU 和 mul)會直接啟動,不會先查詢 occupancy。因此,「一個 linear」實際上是查詢加啟動,而「一個逐元素運算」則只有啟動。
![]() |
|---|
| 圖 9:表格顯示部分運算不會啟動任何核心 |
aten::t、aten::transpose、aten::reshape、aten::view、aten::as_strided 和 aten::_unsafe_view 運算都不會啟動核心。它們在表格(圖 9)中的 CUDA 時間顯示為 0.000us,因為只會在 CPU 上改寫張量元資料(形狀和步幅)。查看錶格的讀者會看到每個 linear 約有 6 個運算名稱,但只有其中一項(mm)會在 GPU 上執行。
為何有兩種 GEMM 核心?
MLP 會把 [batch, seq, dim] 展平為 [batch * seq, dim],再進行矩陣乘法。我們在命令列呼叫中將 batch 設為 64、seq 設為 128,因此下方的 8192(batch * seq = 64 * 128)就是由此而來。
追蹤記錄如下:
| 線性層 | aten::mm 輸入維度 |
M·K·N | cuBLAS 核心 | CUDA 平均時間 |
|---|---|---|---|---|
gate_proj |
[8192,768] x [768,3072] |
8192·768·3072 |
…128x128…stages_32x5_tn |
0.19ms |
up_proj |
[8192,768] x [768,3072] |
8192·768·3072 |
…128x128…stages_32x5_tn |
0.19ms |
down_proj |
[8192,3072] x [3072,768] |
8192·3072·768 |
…128x256…stages_64x3_tn |
0.17ms |
三個 GEMM 的 FLOP 數相同,每個都是 2·8192·768·3072 ≈ 38.7 GFLOP,但 down_proj 快約 10%。運算量相同,形狀不同(N=768 而非 3072),因此 cuBLAS 會選用不同的分塊方式(128×256,並採用較深的 stages_64x3 pipeline),令這種形狀能更有效重用資料。
如想深入瞭解分塊技術,這份優質資源是很好的起點。
這正是表格中有兩列 GEMM(圖 9)的原因:128x128 列對應 gate 和 up,而 128x256 列則對應 down。
torch.compile 會做甚麼?
在編譯 forward 方法並查看圖像之前,先再做一次思考練習:預想追蹤記錄會顯示甚麼。這是個有趣而重要的實驗,每次自行分析效能時都應重複進行。始終以直覺為起點;一旦觀察結果不符,就停下來找出原因。
uv run 03_simple_mlp.py --batch 64 --seq 128 --dim 768 --hidden 3072 --compile
uvx trace-util -f traces -b <hf_uname>/traces
![]() |
|---|
| 圖 10:編譯後 GeGLU MLP 的分析器追蹤記錄 |
Eager 模式會把每個 nn.Linear 展開成一連串分派運算(aten::linear → aten::t → aten::transpose → aten::matmul → aten::reshape → aten::mm)。這些是 ATen 在抵達實際 GEMM 前依次經過的高階包裝層。torch.compile 會移除這條鏈。
執行編譯後的計算圖時,不會再有 linear、matmul、transpose 或 reshape;這些元資料運算已折疊到 mm 的呼叫方式中。我們會看到 3 次直接的 aten::mm 外部呼叫(圖 10)。核心名稱與 eager 模式逐字節相同,證明它是同一個 GEMM:gate 和 up 使用 ...128x128...stages_32x5_tn,down 則使用 ...128x256...stages_64x3_tn。
融合式 Triton 核心
![]() |
|---|
| 圖 11:融合式 Triton 核心 |
這是整個 compile 教學的重點:eager 模式的兩個逐元素核心(GeLU 和 mul)及一個 reshape,融合成單一核心 triton_poi_fused__unsafe_view_gelu_mul_0(圖 11)。讓我們拆解這個名稱:
triton:由 Inductor 的 Triton 後端生成(不是 cuBLAS,也不是 ATen)。poi:逐元素運算(Inductor 以poi標記逐元素核心、以red標記歸約、以per標記持續歸約)。fused__unsafe_view_gelu_mul:合併的運算,包括_unsafe_view(reshape)、GeLU 和 mul。0:計算圖中的唯一識別碼。
為甚麼這樣更好?在 eager 模式中,中間結果 h = gelu(g) 是完整的 [8192, 3072] bf16 張量(約 50 MB),GeLU 核心會把它寫入 HBM,mul 核心隨即再讀取。融合會把它留在暫存器中(晶片內部的記憶體,比 HBM 更接近運算單元)。Triton 核心只需讀取一次 g 和 u,計算 gelu(g) * u,再寫出一次結果,省掉中間張量透過全域記憶體完整往返一次。
使用人工調校的核心
到目前為止,我們一直讓 PyTorch(eager 模式)和編譯器(torch.compile)選擇核心。現在換成人類專家親自撰寫和調校的核心。我們使用 LigerGEGLUMLP 層;可從 Hugging Face Hub 輕鬆取得它,方法是使用 kernels 程式庫。
from kernels import get_kernel
kernels_layers = get_kernel("kernels-community/liger-kernels", version=1).layers
kernels_geglu_mlp = kernels_layers.LigerGEGLUMLP(Config()).to(device, dtype=torch.bfloat16).eval()
完整腳本位於此處:03_kernels_mlp.py。
uv run 03_kernels_mlp.py --batch 64 --seq 128 --dim 768 --hidden 3072
uvx trace-util -f traces -b <hf_uname>/traces
![]() |
|---|
圖 12:LigerGEGLUMLP 層的分析器追蹤記錄 |
圖 12 顯示使用 Hub 上 Liger 核心時,LigerGEGLUMLP 層的分析結果。
為何使用 kernels 程式庫
以 Triton 或 CUDA 編寫核心是一回事,發布核心則是另一回事。核心必須針對你的 GPU 架構、CUDA 版本和 PyTorch 版本組合進行編譯,而這一步通常會出問題(「在我的機器上能運作」、缺少 nvcc、Triton 版本不符)。
kernels 程式庫會把建置工作移出你的電腦。get_kernel("kernels-community/liger-kernels", version=1) 會從 Hugging Face Hub 下載預先建置、版本固定的核心套件,並快取至本機(此處位於 ~/.cache/...kernels-community--liger-kernels)。優點如下:
- 核心會在 CI 中一次編譯,涵蓋多種架構和版本組合。你只需下載正確的二進制檔,不必自行編譯。
version=1會固定使用確切的建置版本,因此每個執行腳本的人都會使用相同核心,不會出現「更新套件後速度變慢」的情況。- 套件提供
.layers屬性,內含可直接替換的nn.Module(例如LigerGEGLUMLP)。你只需把原有模組換成套件提供的模組,模型其他部分完全毋須修改。
為何調校過的核心更好
我們所説的「調校」,具體指兩件事,而且兩者都能在追蹤記錄中看到。
![]() |
|---|
| 圖 13:編譯執行在 GEMM 開始前,會先支付前置運算(Dynamo、guards、prologue)的開銷 |
![]() |
|---|
| 圖 14:Liger 核心沒有前置運算,原本顯示這些運算的方框是空白 |
融合已直接寫入核心。
LigerGEGLUMLP的 forward 實作是down_proj(LigerGELUMulFunction.apply(gate_proj(x), up_proj(x)))。LigerGELUMulFunction會執行單一 Triton 核心_geglu_tanh_forward_kernel,一次計算gelu(gate) * up。這正是我們在torch.compile中看到的做法:中間結果不必經 HBM 往返。在此我們不需要編譯器也能做到,如圖 13 和圖 14 所示(沒有 Dynamo guards、編譯延遲,也沒有重新編譯風險)。啟動參數是按硬件選定的。核心不會隨機猜測區塊大小。Liger 的
calculate_settings會根據欄數選擇參數。
我們應坦白説明這裏的取捨,因為單看數字可能會誤導。Liger 核心的執行時間為 92.8 µs,編譯執行中的 Inductor 融合核心則為 89.4 µs。乍看之下,手寫核心似乎稍慢;但這種比較忽略了它值得使用的成本優勢。
torch.compile 會針對靜態形狀進行特化。Inductor 的 89.4 µs 核心之所以快,正是因為它針對這個特定的 [8192, 3072] 問題生成。只要改變批次大小、序列長度或隱藏維度,Dynamo 就會重新追蹤;你必須再次支付編譯成本,產生新的特化核心。
所以,真正的選擇並非「慢速的人工核心對上快速的編譯核心」,而是快速的通用核心,對上只為特定輸入形狀特化的核心。Liger 核心使用一組啟動參數,毋須重新編譯便可處理任何形狀。它放棄每種形狀特化可節省的最後幾微秒,換來面對形狀變化時的穩健表現。
總結
下表整理每個步驟改變了 GPU 的甚麼,以及保留了甚麼。
| 設定 | 改變之處 | 保持不變之處 |
|---|---|---|
Eager nn.Linear |
基線:偏置加法已折疊至 GEMM 尾聲運算(addmm),因此只使用一個 cuBLAS 核心,而非矩陣乘法加另一個加法核心 |
— |
編譯後的 nn.Linear |
部分 CPU 分派運算(aten::t 檢視的管理工作)消失 |
仍是同一個 cuBLAS GEMM 核心,逐字節相同。Compile 沒有東西可融合 |
| Eager MLP | 5 個 GPU 核心:3 個 GEMM、一個 GeLU 和一個 mul。[8192, 3072] 中間張量會完整經 HBM 往返一次 |
每個 GEMM 仍是與獨立線性層相同、不含偏置的 cuBLAS 核心 |
| 編譯後的 MLP | GeLU、mul 和 reshape 融合成一個 Triton 核心,中間結果留在暫存器中;但要支付編譯前置運算(Dynamo、guards)的成本 | 3 個 GEMM 完全未變,cuBLAS 核心名稱也相同 |
| Liger MLP | 同樣的融合直接寫入手寫 Triton 核心,並按硬件調校啟動參數,不需要 Dynamo、guards 或編譯延遲 | 3 個 GEMM 仍使用相同的 cuBLAS 核心 |
若只記住一個習慣,就是每次查看追蹤記錄前都先做的事:先猜測,再查看。先説明你預期追蹤記錄會包含甚麼,再打開記錄;任何不符之處,都是畫面上最值得探究的線索。
這是PyTorch 效能分析系列的第二站。下一篇會繼續深入,從這個 MLP 區塊走向注意力區塊,最後分析完整模型。
感謝 Noe Flandre 和 Pedro Gabriel Gengo Lourenço 審閲本文早期草稿!
本文經 LLM 潤飾。這絕不代表我們讓 agent 在背景執行並生成整篇文章。團隊中有些成員並非以英語為母語;我們認為 LLM(大多以英文語料訓練)可以修正小型文法錯誤,或改寫較難理解、較不流暢的句子。希望這能解答「如果文章由 LLM 生成,我為甚麼還要讀?」這個疑問。🤗
來源:Hugging Face Blog · huggingface.co













