跳到正文
Hugging Face Blog·· 2026-07-10精選AI 評分62

PyTorch 效能分析(第 3 部分):用 profiler 剖析 Attention

Profiling in PyTorch (Part 3): Attention is all you profile

AI 導讀

Hugging Face Blog 的《PyTorch 效能分析》第 3 篇以 profiler traces 對照手寫注意力與 PyTorch SDPA 各後端的執行情況。

推薦理由

文章對照 CPU 與 GPU trace,展示如何從 kernel 數量、資料搬移及 CPU 開銷,辨認注意力實作的效能收益與成本。

正文 · 繁體中文

Thumbnail of the blog post

「PyTorch 效能分析」系列旨在讓你熟悉閲讀 profiler 追蹤和表格。第一部分分析了加法和乘法等基本數學運算,並介紹 profiler 表格如何揭示效能熱點,以及 profiler trace 如何顯示演算法隨時間執行的次序。

第二部分把加法和乘法包裝成 torch 線性層,再把多個線性層堆疊成多層感知器並分析效能;過程中亦分析了融合核心和手動調優核心。

從 Transformer 架構角度來看,下一個值得分析的邏輯步驟,是另一個基本演算法:注意力。雖然它以二次時間複雜度聞名,但有許多巧妙方法可緩解問題並提升速度。我們不打算在此詳細介紹每種技巧,而是觀察每種技巧在 profiler 中呈現的不同方式。

本文的程式碼位於此處:04_a_naive_attention.py、04_b_inplace_ops_attention.py、04_c_sdpa_attention.py 和 04_d_kernels_attention.py。與之前一樣,建議在另一個分頁開啟程式碼,邊閲讀邊查看。我們使用 NVIDIA A100-SXM4-80GB GPU 執行程式。在 Hugging Face 基礎設施上設定 GPU 並透過 Spaces 開發者模式試驗程式碼非常容易;亦可使用 Hugging Face Jobs 流程執行程式。

簡單注意力

注意力使用 Query(q)、Key(k)和 Value(v)。三者之間的互動可拆解為以下步驟:

  1. 建立注意力分數 scores:matmul(q, k.T)
  2. 縮放分數:scores * scale
  3. 對分數套用因果遮罩:scores.masked_fill(mask, "-inf")
  4. 對分數套用 softmax,取得注意力權重 attn:softmax(scores)
  5. 使用注意力權重重新加權 Value:matmul(attn, v)

因此,注意力實際上由一系列基本運算組成。其中部分我們已經熟悉(矩陣乘法),其餘亦很容易辨認。讓我們用 PyTorch 寫一個簡單注意力模組並分析效能。

class NaiveCausalAttention(nn.Module):
    def __init__(self, head_dim):
        super().__init__()
        self.scale = 1.0 / math.sqrt(head_dim)

    def forward(self, q, k, v, mask):
        scores = torch.matmul(q, k.transpose(-2, -1))
        scores = scores * self.scale
        scores = scores.masked_fill(mask, float("-inf"))
        attn = torch.softmax(scores, dim=-1)
        out = torch.matmul(attn, v)
        return out

開啟 trace 前,先像往常一樣猜猜會看到甚麼。追蹤此模組的 forward 後,我們預期會看到:

  • 一個矩陣乘法核心(q . k.T)
  • 一個乘法核心(縮放)
  • 一項遮罩運算
  • 一個 softmax 核心
  • 一個矩陣乘法核心(atten . v)
uv run 04_a_naive_attention.py
uvx trace-util -f traces/ -b <hf_uname>/traces
CPU lane of the naive attention profiler trace, with the `attn_fwd` block expanded to show its matmul, mul, masked_fill and softmax operations
圖 1:簡單注意力 profiler trace 的 CPU 執行道,標示各個獨立運算

圖 1 顯示 profiler 的 CPU 執行道(GPU 執行道已摺疊,避免資訊過多)。在 attn_fwd(我們標註的 forward 呼叫)中,可以看到與預期完全相同的運算。矩陣乘法已是老朋友,以下新運算也很容易辨認:

  • mul:縮放
  • masked_fill:因果遮罩
  • softmax:softmax 核心

現在展開 GPU 執行道,看看實際啟動了哪些核心。

Profiler trace of naive attention showing the CPU lane above the GPU lane, with each `attn_fwd` step mapping to a cluster of GPU kernels
圖 2:簡單注意力 profiler trace 的 GPU 和 CPU 執行道,標示一個 profiler 步驟對應的一組核心。

圖 2 顯示 GPU 執行道與 CPU 執行道並列。讓我們放大 GPU 執行道中的單一 attn_fwd 區塊,逐一查看各個核心。

Zoomed-in GPU lane of naive attention showing the individual kernels for one step: two matmuls, a mul, a memory copy, a masking kernel and a softmax
圖 3:簡單注意力實作 profiler trace 中放大的 GPU 執行道。

圖 3 顯示一個 profiler 步驟中的各個核心:

  1. 矩陣乘法(Query 和 Key)
  2. 乘法(縮放)
  3. 記憶體複製 🤔
  4. 因果遮罩
  5. softmax(產生注意力權重)
  6. 矩陣乘法(注意力權重和 Value)

其中五項都符合預期。記憶體複製則格格不入,究竟從何而來?線索在於 PyTorch 支援原地運算。使用一般(非原地)方式操作張量時,PyTorch 通常會先複製張量、套用指定運算,再回傳副本。沿着操作順序追查,原因是我們使用了masked_fill。

如果改用原地運算會怎樣?

使用原地因果遮罩的簡單注意力

我們只把 masked_fill 改為 masked_fill_(留意尾端底線,這是 PyTorch 表示原地運算的慣例),然後重新執行同一程式。

def forward(self, q, k, v, mask):
    # q, k, v: [batch, heads, seq, head_dim]
    scores = torch.matmul(q, k.transpose(-2, -1))  # [batch, heads, seq, seq]
    scores = torch.mul(scores, self.scale)
-    scores = scores.masked_fill(mask, float("-inf"))
+    scores.masked_fill_(mask, float("-inf"))
    attn = torch.softmax(scores, dim=-1)
    out = torch.matmul(attn, v)  # [batch, heads, seq, head_dim]
    return out

看看 trace 有甚麼變化。

uv run 04_b_inplace_ops_attention.py
uvx trace-util -f traces/ -b <hf_uname>/traces
類型 CPU 執行流程
圖 4:簡單遮罩 CPU lane of naive attention with out-of-place `masked_fill`, showing several dispatch ops for the masking step
圖 5:原地遮罩 CPU lane of naive attention with in-place `masked_fill_`, showing fewer dispatch ops for the masking step

原地版本(圖 5)在遮罩步驟中包含的 CPU 運算,遠少於非原地版本(圖 4)。這是個令人鼓舞的訊號。接着展開 GPU 執行道,確認實際變化。

類型 GPU 執行流程
圖 6:簡單遮罩 GPU kernels for naive attention including a separate Memcpy kernel before the masking
圖 7:原地遮罩 GPU kernels for naive attention with in-place masking, with the Memcpy kernel gone

GPU 執行道上的 Memcpy 核心徹底消失了(圖 6 和圖 7)。只改一行,每次 forward pass 就少了一個完整核心。單看似乎不多,但這只是一次注意力運算。在 Transformer 大型模型(LLM、Diffusion 模型等)中,每層都會重複一次,而且模型有很多層,因此節省效果很快便會累積(如果因此加薪,至少分我們 10% 才算公平)。

PyTorch 預設採用非原地運算自有原因。為了計算梯度,autograd 必須記住 forward pass 中見過的張量值,因為許多反向公式會重用這些值。原地運算會覆寫記憶體中的數值,令反向傳播讀取錯誤數字。由於我們在 forward 下執行 torch.no_grad,原地運算對我們是安全的,不會進行反向傳播,也沒有需要保護的數據。值得注意的是,原地運算不只像本例一樣節省時間,也會節省記憶體(因為不用額外複製),對 logits 等大型張量特別有幫助!

縮放點積注意力

我們剛才用基本運算建構注意力,甚至省去一個 Memcpy。好消息是,PyTorch 團隊已為我們完成所有工作,並把整個流程封裝成單一函數:

from torch.nn import functional as F

F.scaled_dot_product_attention(q, k, v, is_causal=True)

這一行程式碼取代了手寫模組,而 is_causal=True 甚至讓我們不用手動建立遮罩。值得停下來想想這個呼叫隱藏了多少內容,而且隱藏的不只是程式碼行數。縮放點積注意力(SDPA)並非只有一種實作;底層會分派至數個後端之一,並選取支援目前輸入(資料類型、頭維度、遮罩、硬件等)的最快方案。

官方 SDPA 教學會介紹選擇過程,而各個後端則列於 torch.nn.attention.SDPBackend 列舉中:

from torch.nn.attention import SDPBackend

BACKENDS = {
    "math": SDPBackend.MATH,
    "flash": SDPBackend.FLASH_ATTENTION,
    "efficient": SDPBackend.EFFICIENT_ATTENTION,
    "cudnn": SDPBackend.CUDNN_ATTENTION,
}

一般由 SDPA 自動選擇後端,但我們可以透過 torch.nn.attention.sdpa_kernel context manager 指定特定後端,本文程式碼便採用這種做法。如此即可獨立分析各後端,並觀察它們在 trace 中的不同呈現。讓我們逐一查看。

Math 後端

uv run 04_c_sdpa_attention.py --backend math
uvx trace-util -f traces/ -b <hf_uname>/traces

開啟 trace 前,先猜猜看。我們已把手寫注意力(矩陣乘法、乘法、遮罩、softmax、矩陣乘法)換成一行程式碼,因此 trace 應該會更簡潔、更快。核心數量會減少、CPU 分派會減少,甚至可能融合成單一核心。先看看 profiler 表格。

指標 查看位置 簡單原地版本 SDPA Math
*_fwd CUDA 平均時間 *_fwd 運算的「CUDA 平均時間」欄 1.955 ms 7.239 ms
CUDA 自身累計時間 profiler 表格底部 7.194 ms 27.279 ms

第一個意外是:這行程式碼慢了 3.7x。

Profiler Trace
圖 8:簡單原地注意力 profiler trace,每次 forward 啟動五個 GPU 核心 GPU lane of naive in-place attention with five kernel launches for one forward pass
圖 9:SDPA Math 後端 profiler trace,單次注意力 forward 啟動 20 個 GPU 核心 GPU lane of the SDPA math backend with twenty kernel launches for a single attention forward pass

查看 trace(圖 9)便會明白為何要警惕:Math 後端每次 forward 啟動 20 個 GPU 核心,而簡單注意力實作(圖 8)只啟動 5 個。結果與我們預期相反,讓我們找出原因。

Tensor Core 閒置

在第二部分中,我們學會把核心名稱當作指紋閲讀。現在也用這種方法:

執行 矩陣乘法核心
圖 10:簡單注意力 Matmul kernel name for naive attention in Perfetto, carrying the s16816 bfloat16 Tensor-core GEMM signature
圖 11:使用 Math 後端的 SDPA Matmul kernel name for the SDPA math backend, carrying the sgemm FP32 CUDA-core signature

我們用來擷取這些 trace 的 A100 配備 Tensor Core,這種專用硬件可加速矩陣乘法,速度遠勝一般 CUDA Core。要理解其重要性,需要了解 GPU 內部結構。Streaming Multiprocessor(SM)是 GPU 的運算單元;每個 SM 有兩種算術單元:CUDA Core 和 Tensor Core。CUDA Core 用途廣泛,每次處理少量元素;Tensor Core 則可透過一條指令,把一整個小型矩陣 tile 相乘並累加。問題很簡單:「每個後端有沒有使用快速路徑?」

核心名稱能回答這個問題。簡單核心(圖 10)中的 s16816 是 bfloat16 Tensor Core 矩陣乘法的標記(即 16x8x16 Tensor Core 指令),所以簡單版本走快速路徑。sgemm(圖 11)則是傳統單精度(FP32)矩陣乘法,會在一般 CUDA Core 上運行。換言之,Math 後端完全沒有使用 Tensor Core:為換取數值準確度,它會把張量升級為 FP32(即使輸入為 bf16,搬移數據量也會加倍),並改用較慢的 CUDA Core。

建立因果遮罩

在簡單版本中,我們只建立一次因果遮罩並重用。此處改為傳入 is_causal=True,Math 後端會替我們建立遮罩,但每次呼叫都會重新建立一次。你可以在 CPU 執行道看到:

CPU lane of the SDPA math backend showing the ops that rebuild the causal mask: aten::ones, aten::tril, aten::scalar_tensor, aten::fill_ and aten::where
圖 12:顯示遮罩運算的 CPU 執行道

圖 12 中可看到以下內容:

aten::ones -> aten::tril            build a [seq, seq] lower-triangular matrix
aten::scalar_tensor -> aten::fill_  make the -inf fill value
aten::where                         turn it into an additive bias (0 or -inf)

在 GPU 上,這表現為一個 triu_tril_kernel、數個 where 核心,以及一個 add_。讓我們不用再考慮遮罩的便利旗標,並沒有消除這些工作,只是把工作往下移了一層,導致每次 forward 都從頭重建遮罩。

安全 Softmax

我們手寫的版本呼叫一般 aten::softmax。Math 後端則呼叫 aten::_safe_softmax,差異同樣可從額外核心看出(圖 13):

GPU lane of the SDPA math backend showing the extra kernels that aten::_safe_softmax launches compared to a plain softmax
圖 13:安全 Softmax,顯示相較一般 Softmax 增加的核心

若一整列都被遮罩(每項都是 -inf),一般 Softmax 會計算 exp(-inf)/sum(exp(-inf)) = 0/0 = NaN。_safe_softmax 正是為了防範這種情況。簡單核心沒有處理,會在這個邊界情況中悄悄產生 NaN。

Math 後端有甚麼用途?

總括而言,Math 後端是參考實作,以直接、安全處理資料類型和 NaN 的方式,把注意力拆解為基本 ATen 運算。它本質上就是我們手寫的簡單注意力,只是更謹慎;也正是這種謹慎令它非常慢。

它的目標不是速度,而是任何情況下都能運作,因此是完美的基準。接下來分析的每個後端(Flash、Efficient、cuDNN),都嘗試把 20 個 GPU 核心融合成幾乎單一核心,在 bf16 下運行,而且完全不實體化中間矩陣。

Efficient 後端

uv run 04_c_sdpa_attention.py --backend efficient
uvx trace-util -f traces -b <hf_uname>/traces
Profiler trace of the SDPA efficient backend showing a single fused fmha_cutlassF attention kernel per forward
圖 14:使用 Efficient 後端的 SDPA profiler trace

Math 後端在一個 profiler 步驟中啟動 20 個核心,而 Efficient 後端只啟動一個 fmha_cutlassF_bf16_aligned_64x64_rf_sm80(如圖 14 所示)。

讓我們解讀核心名稱:

  • fmha(融合多頭注意力):注意力的所有基本運算現在都融合為單一運算。
  • cutlassF:以 CUTLASS(NVIDIA 的開源 Tensor Core GEMM 範本)為基礎;F 表示 forward。
  • bf16_aligned:以 bfloat16 運行,不會升級為 FP32,與 Math 後端不同。
  • 64x64:tile 大小。
  • rf(暫存器檔案):工作集會保存在晶片上速度最快的記憶體,即暫存器中。
  • sm80:為 Ampere(A100 的運算能力 8.0)編譯。

這是從 Meta xformers 函式庫發展而來,並整合至 PyTorch 的記憶體高效注意力核心。人們所説的「xformers 後端」,指的就是這個 fmha_cutlassF 核心。

Flash 後端

uv run 04_c_sdpa_attention.py --backend flash
uvx trace-util -f traces -b <hf_uname>/traces
Profiler trace of the SDPA flash backend
圖 15:Flash 後端 trace,每次 forward 執行一個融合的 pytorch_flash 核心

void pytorch_flash 核心(圖 15)是 FlashAttention-2(Tri Dao 的實作),並納入 PyTorch。

繼續閲讀 trace 前,先回答你現在應該會問的問題:為甚麼會有一個稱為「Flash」的完整後端?它為何如此重要?

Flash Attention 為何出現?

先回到 Math 後端。它真正的問題不在於 20 個核心,而在於這些核心彼此傳遞的資料。

步驟 1 會建立完整分數矩陣 attn = q . k.T,其大小為 [seq, seq] 每個注意力頭一個矩陣。序列長度為 4096 時,單一注意力頭就有 4096 x 4096 ≈ 16 million 個數值。這個矩陣會寫入 HBM(GPU 主記憶體),前提是空間足夠;之後為了縮放、遮罩、softmax 等操作,又要反覆讀取和寫入。注意力的成本主要來自與 HBM 之間來回搬移數據,而非矩陣乘法本身。

FlashAttention 正是針對這個問題。它不會先計算整個 s 矩陣再進行縮減,而是逐一處理 k 和 v 的分塊,同時逐步更新 softmax(即「線上 softmax」技巧),並逐塊累積輸出。完整 [seq, seq] 分數矩陣從不寫入 HBM,只會留在晶片上。這項核心概念讓整個注意力流程得以融合為單一核心,並以 bf16 在 Tensor Core 上運行。

為何 Flash 在 profiler 中看起來「不對勁」

Perfetto footprint of the flash kernel reporting an estimated achieved occupancy of 13%
圖 16:Flash 核心估算佔用率為 13%

Flash 會令閲讀 profiler 佔用率的人感到意外:它是最快的後端,但 profiler 顯示佔用率很低(圖 16)。要了解為何這並無問題,先快速説明三個概念。

GPU 核心本質上是一系列由許多小型執行單元執行的指令。這些執行單元(thread)負責載入變數、相加、寫回等工作。每個核心會啟動大量 thread,並按區塊分組以便管理。

區塊會排程至 Streaming Multiprocessor(SM),即 GPU 的主要運算單元。每個區塊只會在一個 SM 上執行;一個 SM 可同時執行多個區塊,前提是資源充足。資源包括暫存器、共享記憶體、可同時駐留的 thread 數和 warp 數。因此,核心佔用率低,代表每個 SM 中駐留的 warp 數少於理論支援上限。

如欲深入瞭解 thread、區塊、grid 等概念,可參閲這份優質資源。

點擊 trace 中的 Flash 核心,便可從其資源佔用一窺究竟(圖 17)。

Resource footprint of the pytorch_flash kernel in Perfetto, showing a high per-thread register count and large shared memory usage per block
圖 17:Flash 核心的資源佔用,每個區塊使用大量暫存器和共享記憶體。

Flash 每個 thread 都使用大量暫存器,每個區塊亦需要大量共享記憶體。例如,一個區塊有 128 個 thread,而每個 thread 使用 255 個暫存器,該區塊便需要 128 × 255 = 32,640 個暫存器。在擁有 65,536 個暫存器的 Ampere SM 上,同一時間只能容納兩個此類區塊。每個 128-thread 區塊有 128 / 32 = 4 個 warp,因此兩個區塊合共只有 8 個駐留 warp。相對最多 64 個駐留 warp,佔用率約為 13%。Flash 佔用率低,不是因為優化不佳,而是每個區塊刻意大量使用晶片上的資源。

這正是設計目的。高佔用率有助透過維持大量待執行 warp隱藏延遲,但不代表工作本身效率更高。Flash 刻意使用這些暫存器和共享記憶體,讓注意力 tile 留在晶片上、大量重用資料,並避免把完整注意力矩陣實體化至全局記憶體。

cuDNN 後端

uv run 04_c_sdpa_attention.py --backend cudnn
uvx trace-util -f traces -b <hf_uname>/traces
Profiler trace of the SDPA cuDNN backend showing a single cudnn_generated attention kernel per forward
圖 18:cuDNN 後端 trace,每次 forward 只執行一個生成式注意力核心。

現在這種模式已很熟悉。與 Flash 和 Efficient 一樣,cuDNN 每次 forward 都提供一個融合式 Flash 風格核心(圖 18)。自然會問:既然 Flash 已融合注意力,PyTorch 為何還要提供另一個 Flash 後端?答案在於由誰編寫核心,以及核心如何構建;這種差異正是 trace 呈現不同的原因。

cuDNN 核心有何不同?

Flash 和 Efficient 都是整合至 PyTorch 的固定預編譯核心,每次都會使用相同二進位檔。cuDNN 是 NVIDIA 自家的深度學習函式庫,其注意力核心會按當前問題生成並調優。它更接近 torch.compile 的程式碼生成機制,而非固定的 cuBLAS 二進位檔。從很長的核心名稱便可看出:

cudnn_generated_fort_native_sdpa_sm80_flash_fprop_wmma_f16_knob_6_128x64x64_4x1x1_cga1x1x1_kernel0_0
  • cudnn_generated:不是預先提供的二進位檔,而是由 cuDNN 生成。
  • flash_fprop:Flash Attention 風格的 forward pass,因此演算法與 Flash 後端屬於同一類。
  • wmma_f16:使用 warp 層級矩陣乘加(WMMA)API,即 16 位元浮點數路徑中的 Tensor Core 路徑。
  • knob_6:cuDNN 會從一組預先調優的配置(「knob」)中選擇。不同形狀會選用不同 knob,類似 cuBLAS 選擇不同 tile 變體。
  • 128x64x64:所選用的 tile 維度。

「按問題生成」這個特點,解釋了 trace 中其他看似異常的地方。

  1. 沒有轉置:CPU 執行道由 _cudnn_attention_forward 直接進入數個 aten::empty 配置,再執行核心,完全沒有 aten::transpose(圖 19、20 和 21)。Flash 和 Efficient 都會加入四次(中繼資料)轉置以重排張量;cuDNN 則能直接使用原生 [B, H, S, D] 格式,因為其生成器會針對該格式產生核心。

    變體 Trace
    圖 19:Flash CPU lane of the flash backend showing four aten::transpose ops before the fused attention kernel
    圖 20:Efficient CPU lane of the efficient backend showing four aten::transpose ops before the fused attention kernel
    圖 21:cuDNN CPU lane of the cuDNN backend going straight to aten::empty allocations and the kernel, with no transpose ops
  2. 它透過 cuLaunchKernelEx 啟動,而非 cudaLaunchKernel:整個系列的其他核心都透過 runtime API cudaLaunchKernel 執行。cuDNN 則使用 driver 層級的擴展啟動方式,並附帶啟動屬性(圖 22)。

    CPU lane of the cuDNN backend showing the cuLaunchKernelEx driver-level launch instead of cudaLaunchKernel
    圖 22:cuDNN 後端 CPU 執行道,顯示使用 driver 層級的 cuLaunchKernelEx,而非 cudaLaunchKernel
  3. Profiler 顯示達成佔用率為 0%:不要照字面解讀,這是量度缺口,並非 GPU 停滯。CUPTI(profiling 後端)無法將佔用率歸因至 driver API 的 cuLaunchKernelEx 啟動,像它處理 cudaLaunchKernel 那樣,所以欄位顯示 0。資源佔用才揭示實際情況(圖 23):每個區塊使用 240 registers × 256 threads = 61,440 個暫存器,而 SM 共有 65,536 個,因此每個 SM 只能容納一個區塊(8 個 warp,約 12.5%),與 Flash 相若。

    Perfetto footprint of the cuDNN kernel reporting 0% achieved occupancy, with 240 registers per thread and 256 threads per block
    圖 23:cuDNN 核心顯示達成佔用率為 0%,每個 thread 使用 240 個暫存器,每個區塊有 256 個 thread

成本轉移至 CPU

「沒有轉置」容易令人以為 cuDNN 在 CPU 上是最精簡的後端,實際情況剛好相反。

後端 CUDA 平均時間 CPU 平均時間
Efficient 277.9 µs 117 µs
Flash 146.8 µs 138 µs
cuDNN 186.3 µs 214 µs

即使完全沒有轉置運算,cuDNN 每次 forward 仍在 CPU 上耗用約 214 µs,多於 Flash(138)或 Efficient(117)。大部分時間都花在 aten::scaled_dot_product_attention 的自身執行時間(整個流程的 26%)及 _cudnn_attention_forward。這是 cuDNN runtime 引擎每次呼叫都選擇並準備執行計劃(搜尋「knob」)的成本。

可見 ATen 運算減少,不代表 CPU 工作量降低,而是工作轉移到函式庫內部,profiler 只會顯示一條粗大而不透明的長條。Trace 突然變得更簡潔時,工作不一定消失了,有時只是移至 profiler 無法細分的地方。

在 GPU 上,cuDNN(186.3 µs)的速度介乎 Efficient 和 Flash 之間。對這種非常適合 Flash 的形狀而言,手寫的 FlashAttention-2 略勝一籌。cuDNN 在其他形狀(更大的頭維度、不同序列長度)往往表現更好,正是因為它能按問題重新調優;但重新調優的成本也就是剛才在 CPU 上付出的代價。

重點總覽

結束前,以下表格總結分析過的各種注意力實作,以及每條 trace 帶來的教訓。

變體 改動內容 每次 forward 的核心數量 Trace 揭示的情況
簡單注意力 以基本運算手動構建注意力(矩陣乘法、乘法、遮罩、softmax、矩陣乘法) 6 非原地操作產生的隱藏 Memcpy,源自 masked_fill。
簡單原地版本 masked_fill → masked_fill_ 5 改一行便可完全移除 Memcpy 核心。
SDPA Math F.scaled_dot_product_attention 指定使用 Math 後端 20 參考實作:FP32 運行於 CUDA Core、每次呼叫都重建遮罩、使用 _safe_softmax。結果正確,但慢約 3.7x。
SDPA Efficient Efficient(xformers)後端 1 單一融合 fmha_cutlassF 核心,以 bf16 在 Tensor Core 上運行。
SDPA Flash Flash 後端 1 單一融合 pytorch_flash 核心(FlashAttention-2)。雖然 13% 佔用率「看起來不對」,速度仍最快。
SDPA cuDNN cuDNN 後端 1 按問題生成核心:沒有轉置,使用 cuLaunchKernelEx,但成本轉移至 CPU 的粗大運算長條。

系列總結

如果整個系列只記住一件事,請記住我們每次查看 trace 前都會重複做的習慣:先猜,再看。

先説出預期 trace 會包含甚麼,再打開 trace,並把每項不符預期之處視為畫面上最值得注意的內容。這三篇文章中的每個實際洞見,包括隱藏的 Memcpy、addmm epilogue、20 核心的 Math 後端、Flash「看起來不對」的佔用率,以及 cuDNN 的粗大 CPU 長條,都是從不符合 trace 的猜測中發現。

Profiler 效能分析不是隻有 GPU 專家才會的獨立高深技能,而是仔細觀察並追問「等等,這為何會發生?」直到恍然大悟的習慣。現在你已具備在自己的模型上實踐所需的詞彙和反射動作。打開 trace、先作預測,再找出不符之處。

感謝閲讀PyTorch 效能分析系列。現在去分析點甚麼吧。🤗

感謝 Noe Flandre 審閲本文早期草稿!

網誌文章經 LLM 潤飾,但這不代表我們讓代理在背景自行生成整篇文章。團隊中有些成員並非英語母語人士;我們認為 LLM(大多以英語訓練)可修正細小文法錯誤,或把較生硬的句子改寫得更簡潔、易讀。希望這有助解答「如果文章是 LLM 生成的,我為何還要讀?」這個問題。🤗

來源:Hugging Face Blog · huggingface.co