PyTorch 效能分析(第 3 部分):用 profiler 剖析 Attention
Profiling in PyTorch (Part 3): Attention is all you profile
Hugging Face Blog 的《PyTorch 效能分析》第 3 篇以 profiler traces 對照手寫注意力與 PyTorch SDPA 各後端的執行情況。
文章對照 CPU 與 GPU trace,展示如何從 kernel 數量、資料搬移及 CPU 開銷,辨認注意力實作的效能收益與成本。
「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-80GBGPU 執行程式。在 Hugging Face 基礎設施上設定 GPU 並透過 Spaces 開發者模式試驗程式碼非常容易;亦可使用 Hugging Face Jobs 流程執行程式。
簡單注意力
注意力使用 Query(q)、Key(k)和 Value(v)。三者之間的互動可拆解為以下步驟:
- 建立注意力分數
scores:matmul(q, k.T) - 縮放分數:
scores * scale - 對分數套用因果遮罩:
scores.masked_fill(mask, "-inf") - 對分數套用 softmax,取得注意力權重
attn:softmax(scores) - 使用注意力權重重新加權 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
![]() |
|---|
| 圖 1:簡單注意力 profiler trace 的 CPU 執行道,標示各個獨立運算 |
圖 1 顯示 profiler 的 CPU 執行道(GPU 執行道已摺疊,避免資訊過多)。在 attn_fwd(我們標註的 forward 呼叫)中,可以看到與預期完全相同的運算。矩陣乘法已是老朋友,以下新運算也很容易辨認:
mul:縮放masked_fill:因果遮罩softmax:softmax 核心
現在展開 GPU 執行道,看看實際啟動了哪些核心。
![]() |
|---|
| 圖 2:簡單注意力 profiler trace 的 GPU 和 CPU 執行道,標示一個 profiler 步驟對應的一組核心。 |
圖 2 顯示 GPU 執行道與 CPU 執行道並列。讓我們放大 GPU 執行道中的單一 attn_fwd 區塊,逐一查看各個核心。
![]() |
|---|
| 圖 3:簡單注意力實作 profiler trace 中放大的 GPU 執行道。 |
圖 3 顯示一個 profiler 步驟中的各個核心:
- 矩陣乘法(Query 和 Key)
- 乘法(縮放)
- 記憶體複製 🤔
- 因果遮罩
- softmax(產生注意力權重)
- 矩陣乘法(注意力權重和 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:簡單遮罩 | ![]() |
| 圖 5:原地遮罩 | ![]() |
原地版本(圖 5)在遮罩步驟中包含的 CPU 運算,遠少於非原地版本(圖 4)。這是個令人鼓舞的訊號。接着展開 GPU 執行道,確認實際變化。
| 類型 | GPU 執行流程 |
|---|---|
| 圖 6:簡單遮罩 | ![]() |
| 圖 7:原地遮罩 | ![]() |
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 核心 | ![]() |
| 圖 9:SDPA Math 後端 profiler trace,單次注意力 forward 啟動 20 個 GPU 核心 | ![]() |
查看 trace(圖 9)便會明白為何要警惕:Math 後端每次 forward 啟動 20 個 GPU 核心,而簡單注意力實作(圖 8)只啟動 5 個。結果與我們預期相反,讓我們找出原因。
Tensor Core 閒置
在第二部分中,我們學會把核心名稱當作指紋閲讀。現在也用這種方法:
| 執行 | 矩陣乘法核心 |
|---|---|
| 圖 10:簡單注意力 | ![]() |
| 圖 11:使用 Math 後端的 SDPA | ![]() |
我們用來擷取這些 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 執行道看到:
![]() |
|---|
| 圖 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):
![]() |
|---|
| 圖 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
![]() |
|---|
| 圖 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
![]() |
|---|
圖 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 中看起來「不對勁」
![]() |
|---|
| 圖 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)。
![]() |
|---|
| 圖 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
![]() |
|---|
| 圖 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 中其他看似異常的地方。
沒有轉置:CPU 執行道由
_cudnn_attention_forward直接進入數個aten::empty配置,再執行核心,完全沒有aten::transpose(圖 19、20 和 21)。Flash 和 Efficient 都會加入四次(中繼資料)轉置以重排張量;cuDNN 則能直接使用原生[B, H, S, D]格式,因為其生成器會針對該格式產生核心。變體 Trace 圖 19:Flash 
圖 20:Efficient 
圖 21:cuDNN 
它透過
cuLaunchKernelEx啟動,而非cudaLaunchKernel:整個系列的其他核心都透過 runtime APIcudaLaunchKernel執行。cuDNN 則使用 driver 層級的擴展啟動方式,並附帶啟動屬性(圖 22)。
圖 22:cuDNN 後端 CPU 執行道,顯示使用 driver 層級的 cuLaunchKernelEx,而非 cudaLaunchKernel 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 相若。
圖 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














