「一連串的失敗」造就了 LLM（下篇）— 從 Attention 到規模革命與對齊

引言

這篇文章接續 上篇。

上篇走過了從圖靈機、夏農的資訊理論、感知器與反向傳播、GPU 加速訓練與克服梯度消失，一直到 Word2Vec/Embedding 把「文字轉成有意義的向量」的技術。

下篇從如何處理脈絡這個問題出發，追蹤 RNN 的結構性極限、Attention 的誕生、演進成 Transformer、GPT-3 的規模革命，以及 RLHF 對齊與效率化的現在。這是 LLM 如何「在沒有被設計的情況下」完成的後半段故事。

5. 如何處理脈絡？ — Attention 的誕生

註記： 本章出現的 LSTM（1997 年）與 RNN 研究，就時序而言比 AlexNet（2012 年）與 Word2Vec（2013 年）更早開始。但要理解「為什麼有順序的資料很難處理」，得先有第 3 章（訓練神經網路與深度的牆）與第 4 章（把文字轉成向量）的知識，所以我用這個順序來講。

為什麼機器翻譯是主戰場

2010 年代前期，NLP 研究者投入最多心力的應用領域是機器翻譯。

理由很單純。翻譯是最嚴格檢驗「它是不是真的理解語言」的任務。你沒辦法把字一個一個換掉就完成翻譯。語序會變，文法會變，文化語感也會變。你必須理解整句話的意思，再用另一種語言重新組裝。

英語:   The cat sat on the mat.
中文:   貓坐在墊子上。

逐字替換: The=那個 cat=貓 sat=坐了 on=在上面 the=那個 mat=墊子
→ 「那個貓坐了在上面那個墊子」 ← 不知所云

正確的翻譯需要重排語序、補上助詞、去掉冠詞
→ 前提是理解整句話的意思

所以「機器能把語言處理到什麼程度」的極限，最早就是在翻譯上暴露出來的。而為了打通那個瓶頸所誕生的技術，後來成了整個 LLM 的地基。

翻譯模型的瓶頸：RNN 的結構性極限（2014 年前後）

當時的翻譯模型使用 RNN（Recurrent Neural Network，遞迴神經網路）。RNN 是當時處理脈絡的最佳解。

RNN 不是全新的發明，而是我們已經看過的零件的組合。它內部的神經元、權重、層與反向傳播都和第 3 章相同。它接收的輸入是第 4 章的 Embedding 向量。要理解 RNN 唯一的新想法，得先知道一般神經網路的極限在哪裡。

為什麼語言很特別：與影像的差異

神經網路到目前為止的成功，都建立在像影像這種可以一次全部輸入的資料上。AlexNet 在分類一張貓的照片時，一百萬個像素是同時進入輸入層的。它不會「先看左上角的像素，再看它右邊那個……」這樣依序處理。因為整體是一次送進去的，也就沒有「記住前面」的必要。

但語言本質上是有順序排列的資料。「貓坐在墊子上」的意思取決於字的順序。「墊子坐在貓上」用的是同樣的字，意思卻完全不同。而且要理解一句話的後半，你必須記得前半說了什麼。

用一個貼近生活的比喻來說，這個問題很像一邊聽課一邊做筆記。

• 一般的網路 = 聽課但不做筆記。每聽完一句就忘掉。只能對剛剛聽到的那一句話有反應。
• RNN（接下來會說明）= 用只有一頁的記事本做筆記聽課。記事本寫滿了，就覆寫掉舊筆記寫新內容。課上完的時候，手上只剩那一頁。

帶著這個比喻，來看技術上的機制。

那麼，用一般的神經網路來處理一句話會怎麼樣？

你可能會想：「每一層都接收前一層的輸出，資訊不就傳下去了嗎？」但那是一個輸入穿過多層的流動（空間方向的流動）。「貓」從輸入層流到隱藏層再到輸出層，是一個字往更深的層推進的過程。

問題在時間方向的流動。當「貓」處理完、「坐」開始處理時，網路會完全重置。隱藏層裡不會留下任何「貓」的痕跡。所以在處理「坐」的時候，沒有辦法知道「是什麼坐了（是貓）」。

RNN 的解法：同一層把記憶帶著走

RNN 的想法是：同一層依序處理不同時點的 token，並把內部狀態（記事本）傳給下一步。

這個「記事本」的專業術語叫 隱藏狀態（hidden state）。還記得第 3 章的「隱藏層（hidden layer）」嗎。那是位於輸入層與輸出層之間、使用者看不到的內部工作空間。RNN 的「隱藏狀態」也是同一個「隱藏」。它被稱為隱藏，是因為它是網路內部的中間資料，既不直接出現在輸入（正在讀的字）也不出現在輸出（翻譯結果）。

和一般的網路比較看看：

重點在於，RNN 裡同一個隱藏層被反覆（Recurrent，遞迴地）使用。這不是不同層之間的接力，而是一層在每個時點反覆運作，並把記事本傳下去，所以它能記得「先前讀過什麼」。

而且記事本不是每個神經元各持一份，而是整層共用一份。如果隱藏層有 1024 個神經元，每個神經元輸出一個數字，那 1024 個數字組成的向量就是「記事本」。到了下一步，這 1024 個數字會作為共用輸入送回整層。

用 React 來比喻

如果你懂 React，把 RNN 的隱藏狀態想成接近 useRef 可能會比較好理解。ref.current 會跨渲染保留值，而且更新時不會觸發 re-render，也就是一個從 React 系統「看不見（hidden）」的內部狀態。RNN 的記事本也一樣：跨越每個時點（處理 token）時，ref.current 被覆寫更新，永遠只保留最新的狀態。舊的值被覆寫之後就消失了。

const memo = useRef(new Float32Array(1024));

function processToken(embedding) {
  memo.current = computeNewState(embedding, memo.current);
  // 舊的 memo.current 被覆寫之後就消失了
}

processToken(embed("貓"));   // memo.current = [貓的資訊]
processToken(embed("坐"));   // memo.current = [貓 … 的資訊]
processToken(embed("下來")); // memo.current = [貓 … 坐下來 的資訊]

每一步 RNN 能用的只有兩樣東西：「現在正在讀的 Embedding 向量」與「上一步傳過來的記事本」。它沒辦法回頭重讀先前的字。已經讀過的資訊，只存在於記事本裡。用聽課的比喻來說，它一直在同一頁記事本上寫，而且沒辦法把課倒帶。

為什麼記事本是「整層一份」而不是「每個神經元一份」

直覺上，每個神經元有自己專屬的記事本似乎比較自然。但 RNN 的記事本之所以整層共用，是因為每個神經元的輸出會成為其他神經元的脈絡。

處理「貓坐了」的時候，假設某個神經元偵測到「主語是貓」，另一個神經元偵測到「動詞是過去式」。處理下一個 token 時，需要「過去式動詞的主語是貓」這種複合的理解。這是單一神經元無法持有的；它只有在結合多個神經元的輸出之後才成立。

把記事本當成全體神經元輸出組成的向量（1024 個數字）來共享，並在下一個時點送進所有神經元，每個神經元就能參照其他神經元在前一個時點偵測到什麼。各自為政的記事本做不到這種「橫向的資訊共享」。

神經元怎麼使用記事本

每個神經元在每個時點，會把「目前 token 的 Embedding」與「前一個時點的記事本」串接成一條輸入向量收下，然後做和第 3 章相同的乘法與加法。神經元自己並不知道「token 到哪裡結束、記事本從哪裡開始」。但透過訓練，token 用的權重與記事本用的權重會學到不同的角色。例如「若目前的 token 是動詞，就加重記事本裡對應主語的資訊」這樣的模式，會自然地以權重值的形式浮現。

每個神經元會學到什麼模式，事前並沒有決定。在訓練的過程中，每個神經元自己找出「某種對預測下一個 token 有用的模式」。那個模式可能抽象到人類無法解釋。這是神經網路被稱為「黑盒子」的理由之一。

RNN 真正的瓶頸：快照沒辦法查詢

記事本的大小（1024 個數字）是設計者在訓練前決定的參數。512 或 2048 都可以，但一旦決定就不會改變，因為神經元的層預期固定數量的輸入（回想第 3 章的結構）。

「因為大小固定，長句子時資訊會滿出來」。乍看之下這像是問題所在。但真正的問題不是大小，而是資料結構。

記事本很像資料庫的快照（傾印檔）。傾印檔反映了過去所有交易的累積結果，但你沒辦法還原某一條特定的 INSERT 敘述。不管把它放大 10 倍還是 1000 倍，這個性質都不會變。

RNN 的記事本也一樣。所有過去的 token 都對現在的狀態有貢獻，但沒辦法個別取出單一 token 資訊這個結構性限制，不管把記事本放多大都不會改變。

在翻譯模型裡，你會先把整個輸入句子讀完，才開始生成輸出句子。

當輸出 RNN 生成翻譯時，它手上只有最終的快照。舉例來說，翻譯「she went to the market. There she met her friend’s girlfriend」。要翻出第三個「her」，輸出 RNN 想去參照輸入句中對應的位置，確認那是「朋友的伴侶」。但個別的 token 已經溶進快照裡了。沒有辦法精準地把其中一個撈出來。

真正需要的不是快照，而是交易紀錄：一種每個 token 的處理結果都個別保存、而且可以查詢的資料結構。這個轉換，成了後面登場的 Attention 的核心。

第 3 章的既視感：梯度消失，又一次

RNN 的問題不只是資訊滿出來。學習本身也有一道牆。

第 3 章我們看過反向傳播如何運作。把輸出和正確答案比較，把誤差訊號往回傳，再調整每一層的權重。這就是追蹤「哪個權重對錯誤貢獻了多少」的「blame（歸責）」機制。

RNN 用的是同一套機制。但第 3 章裡誤差訊號是跨層往回流，在 RNN 裡則是跨時點往回流。

舉例來說，如果在第 50 個 token 預測錯了，原因可能是「第 1 個 token 的處理方式不好」。但誤差訊號必須沿著記事本的鏈往回走 49 次，每一步都縮小一點。結果就是，早期 token 得到的回饋趨近於零，權重沒有被調整，也就是說網路學不會「怎麼把句子的開頭處理好」。

數學完全一樣。第 3 章裡，訊號每穿過一個深層就消失一點。在 RNN 裡，訊號每往回走一段時間就消失一點。變的只有軸，從空間換成時間，而同一個問題又出現了一次。

LSTM：時間軸上的 ResNet（1997 年發明，2014 年起成為翻譯主力）

第 3 章裡，ResNet（殘差連接） 解決了層方向的梯度消失。它透過一條捷徑把輸入加到輸出上，做出一條讓梯度直接通過的「高速公路」。

那時間方向的梯度消失呢？事實上，在 ResNet（2015 年）的 18 年前，也就是 1997 年，就有人提出過同樣想法的解法。那就是 Hochreiter 與 Schmidhuber 的 LSTM（Long Short-Term Memory）。它長年處於冷門位置，直到 2014 年前後深度學習熱潮與 GPU 同時到位，才作為機器翻譯的主力架構開花結果。

LSTM 的核心，是在一般的記事本之外，還有另一種叫做單元狀態的記憶。這條單元狀態是一條在時點之間幾乎原封不動通過的高速公路。一般 RNN 的記事本每一步都要經過複雜的轉換，每次損失四分之一的梯度；而單元狀態的接點只有加法，所以梯度抵達時的強度和出發時差不多。

LSTM 還有一套叫做閘的機制。遺忘閘、輸入閘與輸出閘這三個，替單元狀態控制「要忘掉什麼」「要寫入什麼」與「要讀出什麼」。這讓它能長時間保留重要的資訊，同時丟掉不需要的部分。

LSTM 大幅改善了 RNN 的記憶問題，並在 2014 年到 2017 年前後成為機器翻譯的主力。但一個根本的限制還在：逐次處理。先處理 token 1 才能處理 token 2，先處理 token 2 才能處理 token 3。記憶再怎麼改善，它都用不上 GPU 的平行運算。

給 bug 的一個補丁：Attention

Bahdanau 等人的解法，正是先前提到的「從快照到交易紀錄」的轉換。

第 1 步：把快照變成交易紀錄

RNN 在處理輸入時，每一步都會更新記事本（快照）。傳統上只有最終那份快照會被送給輸出 RNN。Bahdanau 等人的想法是把每一步的快照都存成獨立的副本。

關鍵在於，存下來的不是差異（delta），而是每個時點的完整快照。處理 5 個 token，就存下 5 組 1024 個數字，合計 5120 個。

用 React 來比喻

用 React 來說，Attention 就像在覆寫 ref.current 之前，先用 history.push([...memo.current]) 存一份展開的副本。輸出時就能用 history[i] 取得任何一步的狀態。

回到聽課的比喻，Attention 相當於把課錄下來。不再只依賴筆記（最終的記事本），而是保留課堂上每一刻的錄音。

但光有錄音還不夠。你不可能每次都把兩小時的錄音整個重聽一遍。你需要一套判斷「現在該重聽哪一段」的機制。這就是 Attention 的核心。

第 2 步：學會該注意哪一份快照

當輸出 RNN 生成翻譯的每一個字時，會跑以下的流程：

1. 取出輸出 RNN 目前的狀態（「我現在想翻的是什麼」）
2. 對每一份保存的快照計算相關度分數
3. 用 softmax 把分數正規化成總和為 1.0 的權重
4. 依權重對快照取加權平均，做出脈絡向量
5. 用這條脈絡向量生成輸出的字

輸出 RNN 正要生成「she」的場面:

  保存的快照:
    copy₁（處理完「she」之後）  copy₂（處理完「went」之後）  copy₃（處理完「market」之後）
    copy₄（處理完「friend」之後）  copy₅（處理完「she」之後）

  步驟 2 - 計算相關度分數:
    score(目前狀態, copy₁) = 4.2   ← 高！第一個「she」有關聯
    score(目前狀態, copy₂) = 0.1
    score(目前狀態, copy₃) = 0.8
    score(目前狀態, copy₄) = 1.5
    score(目前狀態, copy₅) = 0.3

  步驟 3 - 用 softmax 正規化（合計 = 1.0）:
    權重 = [0.70, 0.02, 0.08, 0.15, 0.05]

  步驟 4 - 加權平均:
    脈絡 = 0.70×copy₁ + 0.02×copy₂ + 0.08×copy₃ + 0.15×copy₄ + 0.05×copy₅
         = 一條強烈偏向 copy₁（第一個「she」）的向量

  步驟 5 - 用這條脈絡生成「she」

這個決定「要對哪份快照注意多少」的權重，就是 Attention（注意） 這個名字的由來。人在讀文章時，不會對每個字投入相同的注意力，而是把注意力集中在與當下脈絡相關的部分。Attention 機制正是把這件事用數值重現出來。

而分數計算所用的權重，同樣是由反向傳播訓練出來的參數。它會自動從資料中學到「翻譯動詞時，給主語的快照高分」這類模式。

Attention 也改善了梯度消失

Attention 還有另一個重要的效果。從輸出到每一份快照的直接連線，成了梯度的捷徑。

因為梯度可以透過 Attention 的直達路徑一步抵達任何一個 token，它不再需要沿著 RNN 的鏈往回爬，梯度消失也就大幅緩解了。

這並不是什麼宏大的願景。它是為了修「長句子翻譯準確度會掉」這個 bug 而打的工程補丁。但結果上，它解決了快照的限制（無法查詢特定 token），甚至還改善了梯度消失。

補丁變成了架構：Transformer（2017）

Vaswani 等人提出了一個問題：「RNN（逐次的機制）真的有必要嗎？能不能只用 Attention 來翻譯？」

回頭看目前為止的改良，即使是 Attention+RNN，也還留著 RNN 那部分的限制：快照的生成是逐次的。

在 Attention+RNN 裡，參照（重讀）可以平行化，但快照的生成仍然由 RNN 負責。因為每一份快照都依賴前一份，它們只能依序產生。

Attention + RNN: 參照改善了，但快照生成仍然是逐次的

  snapshot₁ = f("cat", empty)        ← 要先算這個
  snapshot₂ = f("sat", snapshot₁)     ← snapshot₁ 沒好就算不了
  snapshot₃ = f("mat", snapshot₂)     ← snapshot₂ 沒好就算不了

  每份快照都依賴前一份 → 一條鏈 → 無法平行化

Vaswani 等人的洞見，是把這條鏈（記事本的鏈）本身丟掉。

沒有 RNN 要怎麼理解脈絡

在 RNN 裡，token 的順序是由記事本的鏈隱含地表示的。正因為你先處理「貓」再處理「坐」，「坐」那一刻的記事本裡才含有「貓」的資訊。處理順序＝脈絡順序。

Transformer 採取完全不同的做法。每個 token 從一開始就帶著自己的位置編號。

因為位置資訊包含在資料本身裡，同時處理所有 token 也不會失去順序。而且每個 token 都參照其他每一個 token。這就是 Transformer 的 Self-Attention。

先前的 Attention 是「輸出 RNN 參照輸入的快照」。在 Self-Attention 裡，輸入的 token 彼此互相參照。「貓」看著「坐」，「坐」看著「貓」，全部同時發生。

在 RNN 裡有一條依賴鏈：「要算記事本₃ 就需要記事本₂，而記事本₂ 需要記事本₁」。Transformer 沒有這條鏈。每個 token 的 Embedding 不依賴其他 token 的處理結果，這就是它們能同時處理的原因。

Transformer 依然是「深」的

聽到「所有 token 同時處理」，可能會讓人覺得這個網路很「扁」。但Transformer 依然是很深的多層結構。GPT-3 有 96 層。

被平行化的只有 token 方向。**層的方向仍然依序處理。**每一層都在精煉表示。Layer 1 學到「坐＝動詞」，Layer 2 學到「貓是坐的主語」，更深的層則學到複雜的語意關係。越深，理解越豐富，這和第 3 章是同一個原理。

反向傳播（blame）同樣以和第 3 章相同的機制沿著層往回流。此外，透過 Self-Attention 的連線，blame 訊號可以從任一 token 直接抵達任一 token，不必像 RNN 那樣沿著長鏈往回爬，梯度消失因此大幅緩解。而 ResNet 的殘差連接則防止了層方向的梯度消失。

處理時間：為什麼 Transformer 比較快

比較一下處理時間。RNN 需要的逐次步驟數是 token 數 × 層數，所以 100 個 token 穿過 96 層就是 9,600 步。Transformer 需要的只有層數，因為每一層裡的 token 是同時處理的：96。

不過，Transformer 的每一步比 RNN 計算量更大。在 Self-Attention 裡所有 token 都參照所有 token，因此需要與 token 數平方成正比（n²）的計算。100 個 token 就是 10,000 組分數計算。

總計算量有可能是 Transformer 比較多。但重的計算可以在 GPU 上平行化。這和第 3 章的 AlexNet 是同一個結構：4,000 個小學生同時解加法。n² 的分數計算彼此獨立，所以能在 GPU 的數千個核心上同時執行。

另一方面，RNN 的逐次步驟不管 GPU 多強都無法平行化，因為前一步沒結束就無法往前。

結果，Transformer 一口氣解決了本章看到的所有問題：

丟掉 RNN、只用 Attention，讓訓練變得極快。更快，意味著你能用更多資料訓練更大的模型。

一個為了加速翻譯而生的架構，因為讓規模成為可能，成了整個 LLM 的地基。

6. 更大就更聰明嗎？ — 規模與湧現

擴展法則的發現（2020）

「把模型做大，效能就會提升」原本只是個經驗法則。OpenAI 的 Kaplan 等人把它寫成了公式：

效能會對參數量、資料量與計算量這三個量，依照一條平滑且可預測的法則改善。

具體看看這三個變數：

計算量是什麼

參數量與資料量很直覺，但計算量需要稍微說明一下。

計算量是訓練期間 GPU 執行的浮點運算（FLOP）總數。模型每處理一個批次，正向與反向傳遞都會跑大量的矩陣運算。那些運算的累積總量就是計算量。

Kaplan 等人用一個近似式表達了三者的關係：

C ≈ 6 × N × D

所以計算量大致與參數量和資料量的乘積成正比。與其說計算量是獨立的第三個變數，不如說它是你能投入的總預算。預算一旦定下，模型要做多大、要餵多少資料，也就跟著決定了。

增加計算量的方法很單純：GPU 的數量 × 訓練時間。訓練 GPT-3 花掉約 3.14×10²³ FLOPs。那是數千顆 GPU 跑上數週的結果。所以增加計算量，講白了就是投入金錢與時間。

註記：Chinchilla 法則（2022） Kaplan 的擴展法則建議「當計算預算變大時，多分配一些去把模型做大」。但 2022 年，DeepMind 的 Hoffmann 等人把它修正為「多分配一些給資料量」（Chinchilla 法則）。這個發現是說，即使計算預算相同，最佳的分配比例也不一樣。兩者一致同意的是，計算量才是根本的限制資源。

這是一張「地圖」。你可以事先預測「用這麼多資料訓練這種大小的模型，大概會得到這樣的效能」。結果看得見，大筆投資就下得了決定。

從 Transformer 到「GPT」 — 目的的轉向

Transformer 是為了翻譯而生的。但 GPT（Generative Pre-trained Transformer）想解的是和翻譯不同的問題。

2018 年，OpenAI 的 Radford 等人面對的問題是這個：

NLP 有各式各樣的任務（問答、文件分類、情感分析等），但替每個任務蒐集大量標註資料太貴了。

沒有標註的文本（網路上的文章）非常多。能不能先用它學會「對語言的通用理解」，再用少量標註資料適應個別任務？

這就是 GPT-1 的核心想法：

1. 預訓練：用大量文本訓練，目標只是「預測下一個字」
2. Fine-tuning：用少量的個別任務資料調整權重

架構只用了 Transformer 的 Decoder 部分。翻譯用的 Encoder-Decoder 結構並不需要；「讀文本、預測後續」這種簡單結構就夠了。

GPT-1 → GPT-2 → GPT-3：同一份設計圖，不同的規模

這裡是重點。**GPT-1、GPT-2 與 GPT-3 的架構幾乎相同。**保留基本設計，只改規模，看看會發生什麼。這就是這三個世代的本質。

GPT-1 證明了「預訓練＋Fine-tuning」的有效性。但它每個任務都要做 Fine-tuning。

GPT-2 把模型放大了 13 倍，資料也增加了。於是它不做 Fine-tuning 也能處理一部分任務（zero-shot）。如同論文標題所說，發現是「語言模型是無監督的多任務學習器」。但效能還是有限。

GPT-3 又放大了 117 倍。架構改動極小（大約就是部分導入 sparse attention）。用同一份設計圖，光靠規模就造成了質的飛躍。

Few-shot 學習：訓練之後發生的事

這裡我回答一個讀者很容易產生的疑問。

「Few-shot 是訓練的一部分嗎？還是訓練之後才發生的事？」

答案是訓練之後。Few-shot 是推論階段（使用者實際使用模型時）的技巧。

整理一下 GPT-3 的訓練流程：

1. 訓練時：只從網路蒐集來的大量文本中學習「預測下一個字」。沒有教它翻譯，也沒有教它寫程式。目標只有一個：提高預測下一個字的準確度
2. 推論時（Few-shot）：使用者在提示詞裡示範幾個範例。模型從脈絡中讀出那個模式，並依同樣的模式生成後續

GPT-3 並沒有被明確地訓練翻譯。但因為訓練資料裡有英日對譯文本，隨著「預測下一個字」的能力擴大，抓住模式並正確接下去的能力就湧現了。

生成程式碼也一樣。因為訓練資料裡有 GitHub 的程式碼，只要示範幾個「函式說明 → 程式碼」的模式，它就能寫出從沒見過的函式。

為什麼「大霹靂」發生在 GPT-3？

zero-shot 在 GPT-2 就已經部分可行了。那 GPT-3 到底改變了什麼？

答案是越過了一道閾值。

在許多任務上，模型大小與效能的關係是這樣走的：

• 1.25 億到 3.5 億參數：效能接近隨機
• 13 億到 130 億參數：緩慢改善
• 1750 億參數：突然躍升

這就是湧現能力。就像物理裡的相變（水變成冰的那一瞬間），量的變化越過某個閾值之後，會觸發質的變化。GPT-2 差一點就到那個閾值，而 GPT-3 越過了。

為什麼會有閾值？訓練期間，為了「預測下一個字」，模型會把文本中包含的所有模式（文法、邏輯、事實、任務結構）編碼進自己內部。小模型容量不足，只能學到個別模式的碎片。但當規模夠大時，這些模式會彼此結合，浮現成沒有被明確訓練過的能力。這就是湧現的本質。

GPT-3 並沒有用新架構去設計智慧。**把同一份設計圖放大到越過閾值，讓一個沒有被設計出來的智慧出現了。**這就是現在 LLM 時代的起點。

7. 變聰明之後的課題 — 從 Fine-tuning 到對齊，以及規模之外

GPT-3 的通用性驚人，卻很難用。它會生成帶有種族歧視的文字，會不回答問題而接著寫下去無關的內容，還會滿臉自信地說謊。「預測下一個字」的能力，和「給出對人類有用的回應」的能力，並不是同一件事。

從這裡開始的歷史分成三個階段。

Fine-tuning 是怎麼運作的

我們把 GPT-1 時登場的 Fine-tuning 再看仔細一點。

預訓練好的模型學到了語言的通用模式，但沒有針對特定任務（情感分析、問答等）最佳化。Fine-tuning 就是把這個通用模型「調律」到特定目的的過程。

機制很單純：

1. 準備任務資料：例如數百到數千筆「評論文字 → 正面／負面」的配對
2. 從預訓練好的權重出發：不從零學起，而是從已經理解語言的權重開始
3. 用任務資料再訓練：機制與一般訓練相同（正向傳遞 → 計算損失 → 反向傳遞），只是學習率更小、步數更少

為什麼少量資料就有用？因為預訓練已經取得了文法、詞彙與世界知識。Fine-tuning 就像「教一個已經會說英語的人醫學術語」，語言的基礎不必重教。

InstructGPT：用人類回饋來「對齊」（2022）

GPT-3 的問題在於它「聰明，但沒有對齊人類的意圖」。為了解決這件事，OpenAI 開發了把 Fine-tuning 概念延伸的 RLHF（Reinforcement Learning from Human Feedback）。

RLHF 是一條三階段的管線：

第 1 階段：監督式 Fine-tuning（SFT）

約 40 位人類標註者手寫了約 13,000 份對提示詞的「理想答案」。用這些資料做一般的 Fine-tuning，教會模型「被問就回答」這個基本行為。

第 2 階段：訓練獎勵模型

模型對同一個提示詞生成多個答案，人類再依「哪個比較好」排出高低。從這份排序資料訓練出一個把「什麼是好答案」量化的獎勵模型。

第 3 階段：以強化學習最佳化

原本的模型生成答案，獎勵模型評分，再用那些分數更新原模型的權重。模型會被調整成傾向生成「人類偏好的答案」。

結果令人震驚。**13 億參數的 InstructGPT，生成的答案比未經處理的 1750 億參數 GPT-3 更受人類青睞。**參數量小了 130 倍的模型，光靠「已對齊」就翻轉了結果。

這是一個重要的教訓：把模型做大，並不是通往更好效能的唯一一條路。

Fine-tuning 現在的位置：什麼時候需要，什麼時候不需要

在 GPT-1 的時代，每個任務都非做 Fine-tuning 不可。如今 GPT-3 讓 Few-shot 可用，InstructGPT 讓模型連 zero-shot 都能遵循指示，Fine-tuning 的角色也就變了。

標註資料依然重要，只是用途變了。GPT-1 時代它是用來「教會任務」的；現在主要是用來「對齊模型的行為」。RLHF 的人類排序資料就是典型例子。

此外，隨著 LoRA（Low-Rank Adaptation）與 QLoRA 這類參數高效微調（PEFT） 的出現，現在可以只加上少量參數就完成 Fine-tuning，不必更新全部權重。Fine-tuning 的成本比 2020 年代初期降低了九成以上。

規模之外：LLM 現在正往哪裡演進？

「增加參數、資料與計算量，它就會變聰明。」擴展法則解釋了 GPT-3 的成功。但從 2024 年前後開始，這個策略撞上了牆。

牆 1：資料枯竭

網路上的高品質文本資料是有限的。截至 2026 年，人類寫的高品質文本據說已經快用完了。

牆 2：成本的極限

預訓練一個更大的模型需要數億美元等級的投資，而報酬遞減已經開始顯現。

在 NeurIPS 2024 上，OpenAI 共同創辦人 Ilya Sutskever 宣告：

「我們所認識的那種預訓練將會結束。2010 年代是規模的時代。現在我們回到了驚奇與發現的時代。」

那麼除了規模之外，還有哪些演進的軸？以下是目前主要的幾種做法。

軸 1：深化後訓練

從 InstructGPT 開始的 RLHF，現在被進一步精煉。預訓練（從大量文本取得基礎能力）之後所做的額外訓練，也就是後訓練，已經成為把模型能力引出來的主戰場。

• RLHF / RLAIF：以人類或 AI 的回饋進行對齊（Anthropic 與 OpenAI 持續在改良）
• DPO（Direct Preference Optimization）：不經過獎勵模型，直接從人類偏好資料做最佳化的高效方法

軸 2：推論階段計算量

不去放大訓練，而是讓它在推論時想得更多的做法。

OpenAI 的 o1/o3 系列與 Anthropic 的 Claude（擴展思考模式）是代表。回答之前，模型會生成一段「思考鏈」，一步一步推理。它不增加訓練階段的計算量，而是靠增加推論階段的計算量來提升效能。

擴展法則問的是「要把多少計算量投進訓練」，而這是一條新的軸：「要把多少計算量投進推論」。

軸 3：合成資料與蒸餾

如果人類資料用完了，那就讓 AI 來造資料。

• 蒸餾：用大模型（教師）生成的答案去訓練小模型（學生）。DeepSeek-R1 的蒸餾版與 Llama 的衍生模型就是這樣做出來的
• Self-Play：模型與自己對話，互相出題也互相解題，藉此提升能力

在 2026 年的典型工作流程裡，人類寫下 200 份種子樣本，前沿模型把它擴充到數萬份，套上品質過濾，再訓練一個小模型。

小結：三個時代

這三者並不互斥，現在的前沿模型三種都用。但重心明顯移動了，從「更大就更聰明」變成「用得聰明，小的也很強」。

總結

LLM 是一堆概念的累積，它們在沒有人以 LLM 為目標的年代裡，分別作為不同問題的答案堆疊起來。

每一位研究者都只看著眼前的問題。沒有藍圖，這些零件卻在八十多年間湊在了一起。

就在此刻，某個人為了越過一道完全不同的牆而正在寫的論文，也許就是十年後的 AI 的一部分。