跳到正文
Hugging Face Blog·· 2026-06-11精選AI 評分61

PyTorch 效能分析(第二部分):從 nn.Linear 到融合式 MLP

Profiling in PyTorch (Part 2): From nn.Linear to a Fused MLP

AI 導讀

Hugging Face Blog 第二篇 PyTorch 效能分析教程,從 nn.Linear 追蹤至 GeGLU MLP。

推薦理由

文章對比 eager、torch.compile 與 Liger,展示 MLP 融合如何減少 HBM 往返,以及固定形狀特化與跨形狀通用的取捨。

正文 · 繁體中文

Thumbnail of the blog post

在《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-80GB GPU 執行腳本。在 Hugging Face 基礎設施上設定 GPU 十分簡單,你可以使用 Spaces 開發模式執行腳本進行實驗。你也可以使用 Hugging Face Jobs pipeline 執行腳本。

開始之前,先簡短回顧兩個接下來會反覆用到的概念:

  1. GPU 核心(kernel)是由 GPU 上許多執行緒平行執行的程式。
  2. 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 網址。

PyTorch profiler trace of an `nn.Linear` forward pass: three short Profile Steps and `linear_fwd` annotations on the CPU lane, a tiny kernel on the GPU lane, and a long `cudaDeviceSynchronize` bar at the end
圖 1:nn.Linear 的分析器追蹤記錄

圖 1 顯示線性層一次 forward 呼叫的分析器追蹤記錄。我們追蹤線性層的 forward 呼叫,並使用與前面追蹤記錄相近的 schedule 設定:wait=1、warmup=1 和 active=3。因此,CPU 和 GPU 軌道中都會看到 3 個 Profile Step。

轉置有甚麼作用?

Zoomed in CPU dispatch chain showing the aten::t transpose op nested before aten::addmm inside aten::linear, with no matching activity on the GPU lane
圖 2:CPU 軌道中的轉置

如圖 2 一樣放大分析器追蹤記錄後,會看到一個 aten::t(轉置)運算,接着是 aten::addmm(乘法和加法)運算。由此可知,nn.Linear 會先轉置權重參數,再與輸入相乘,這就是出現 aten::t 運算的原因。

要留意,aten::t 並不會真正複製或重組資料:它只會在 CPU 上改寫張量元資料(形狀和步幅),以表示轉置後的矩陣,也不會在 GPU 上啟動核心。你可以透過兩種方法確認:查看追蹤記錄中的 GPU 軌道,或檢查分析器表格中的 aten::t 列及其 CUDA 執行時間。

為何沒有獨立的 mul 和 add 核心?

Profiler trace of the linear layer with the dispatch chain highlighted, showing aten::linear, aten::t and aten::addmm but no separate aten::add op
圖 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 分派鏈包含的項目較多。

Eager CPU dispatch chain with the aten::t transpose and aten::addmm boxed separately under aten::linear
圖 4:Eager 分派鏈中,aten::linear 依次呼叫 aten::t(轉置)和 aten::addmm
Compiled CPU dispatch chain showing a Torch-Compiled Region and a single aten::addmm call, with no transpose op
圖 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)。

Conclusions section of the GLU Variants Improve Transformer paper, with the closing sentence attributing the architectures' success to divine benevolence highlighted
圖 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 和乘法。查看資料前先作出預期,是分析效能過程中最有用的習慣:閲讀追蹤記錄是為了確認或推翻猜測,而不是從零開始猜。

Profiler trace of the GeGLU MLP forward pass, with five boxed groups on the CPU lane labelled linear, linear, gelu, mul, linear
圖 7:GeGLU MLP 的分析器追蹤記錄
Occupancy Queries highlighted in the linear projection traces
圖 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」實際上是查詢加啟動,而「一個逐元素運算」則只有啟動。

Profiler table for the GeGLU MLP listing op names and their CUDA times, where metadata ops like aten::transpose and aten::as_strided show 0.000us of CUDA time
圖 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
Profiler trace of the compiled GeGLU MLP showing three aten::mm calls and one fused triton kernel on the CPU lane, labelled mm, mm, fused, mm
圖 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 核心

Compiled MLP trace with the triton_poi_fused__unsafe_view_gelu_mul_0 kernel boxed on the CPU lane, replacing the separate gelu and mul kernels from the eager run
圖 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
Profiler trace of the LigerGEGLUMLP forward pass showing three aten::linear groups and a single LigerGELUMulFunction group on the CPU lane
圖 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)。你只需把原有模組換成套件提供的模組,模型其他部分完全毋須修改。

為何調校過的核心更好

我們所説的「調校」,具體指兩件事,而且兩者都能在追蹤記錄中看到。

Compiled MLP trace with the TorchDynamo, prologue and guard pre-ops boxed on the CPU lane before the compiled graph runs
圖 13:編譯執行在 GEMM 開始前,會先支付前置運算(Dynamo、guards、prologue)的開銷
LigerGEGLUMLP trace with an empty box where the compile pre-ops would be, showing the hand-written kernel has no Dynamo or guard overhead
圖 14:Liger 核心沒有前置運算,原本顯示這些運算的方框是空白
  1. 融合已直接寫入核心。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、編譯延遲,也沒有重新編譯風險)。

  2. 啟動參數是按硬件選定的。核心不會隨機猜測區塊大小。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