在《Transformer 和 FPGA 都是電路》裡,我們用一句話概括過模型是怎麼訓練的:先算出“錯誤”對每個引數的坡度,再朝下坡的方向挪一小步。這句話沒錯,但它跳過了所有細節。真正訓練一個模型時,螢幕上看到的是這樣一串數:
step 0 loss 0.615step 1 loss 0.594step 2 loss 0.572step 3 loss 0.548step 10 loss 0.336step 20 loss 0.076step 40 loss 0.030step 是第幾步,loss 叫作損失,可以先理解成“模型現在錯得有多厲害”。它一步步變小,說明模型越來越對。可是 0.615 是怎麼算出來的?電腦在每一步裡到底做了什麼,才讓它變成 0.594?為什麼前十步降得慢,第十步到第二十步又降得快?
這串數來自一個真的 Transformer,只不過它小到只有 10 個引數。小到這個程度,每一箇中間結果都寫得下。不過在開啟它之前,我們先用一個更小的東西,把“訓練”這件事本身弄清楚。
一、熱身:一個旋鈕
一臺只有一個旋鈕的機器
設想一臺機器,輸入一個數 ,輸出 。 是機器上的一個旋鈕,可以擰到任何讀數。我們希望輸入 2 的時候,輸出是 6。
你當然一眼就看出 應該是 3。但假裝我們不知道,只能從某個讀數開始,比如 ,一點點去擰。神經網路的訓練就是這件事,只不過旋鈕有成千上億個,沒有人能一眼看出答案。
先要有一個數,說明“現在差多遠”。 時輸出是 2,目標是 6,差了 −4。差值可正可負,我們把它平方,得到一個永遠不小於 0 的數,叫作損失:
時 ;擰對了,,。訓練的目標就是把 擰小。
導數告訴我們往哪邊擰
是 的二次函式,畫出來是一條開口向上的拋物線,谷底在 (圖 1)。站在 這一點,該往左擰還是往右擰?看腳下的坡就知道了。
坡度就是導數。 的導數是 , 時等於 −16。負數表示往右是下坡: 調大一點, 會變小,而且 每增加一點點, 大約減少這一點點的 16 倍。
於是規則很簡單:導數是負的就把 調大,是正的就調小,調多少和導數成正比。寫成式子:
讀作“伊塔”,叫作學習率,管的是一步邁多大。取 : 從 1 變成 ,損失從 16 降到 5.76。再算一次導數,,於是 變成 2.28,損失 2.07。這樣一步步走下去, 依次是 2.568、2.741、2.845……越來越接近 3。
這就是梯度下降:算坡度,往下坡挪一步,再算坡度,再挪一步。注意步子是越來越小的,因為越靠近谷底,坡越緩,導數越小。
步子邁多大
學習率不能隨便取(表 1)。
| 學習率 | w 的變化 | 結果 |
|---|---|---|
| 0.05 | 1 → 1.8 → 2.28 → 2.568 → 2.741 | 一步步靠近 3 |
| 0.125 | 1 → 3 → 3 → 3 → 3 | 一步到位 |
| 0.25 | 1 → 5 → 1 → 5 → 1 | 在 1 和 5 之間來回跳 |
| 0.3 | 1 → 5.8 → −0.92 → 8.488 → −4.683 | 越跳越遠 |
每一步離谷底的距離都乘上同一個數 1 − 8 × 學習率:0.05 時是 0.6,0.125 時是 0,0.25 時是 −1,0.3 時是 −1.4。
這個例子簡單到可以算清原因。新的 減去 3,等於舊的 減去 3 再乘上 。 時乘的是 0.6,離谷底的距離每步縮到六成; 時乘的是 0,一步就到; 時乘的是 −1,從谷底一邊跳到另一邊,距離不變,永遠在 1 和 5 之間來回; 時乘的是 −1.4,每跳一次離得更遠。導數只說明腳下這一點的坡,步子太大,就會跨過谷底。
兩個旋鈕:偏導數
機器再加一個旋鈕 ,輸出變成 。輸入還是 2,目標還是 6,損失是 ,從 、 出發。
現在 同時取決於兩個數。辦法是一次只看一個:先假裝 不動,只對 求導;再假裝 不動,只對 求導。這樣得到的叫偏導數,寫作 和 ,讀作“L 對 w 的偏導”。
所有引數的偏導數排在一起,叫作梯度。這裡的梯度是 ,兩個旋鈕各自往大里擰, 擰得多一些。
一條會反覆用到的規律
把上面兩個偏導數拆開看。兩個式子前面都有 ,它是損失對輸出 的導數:輸出每變一點,損失變多少。、 時它是 −8,意思是輸出應該變大。後面再乘一個數: 乘的是 2, 乘的是 1。這兩個數正是它們在 裡各自乘著的那個輸入。
所以一個引數的偏導數 = 損失對輸出的導數 × 這個引數乘著的輸入。輸入大,這個旋鈕對輸出的影響就大,分到的“責任”也大;輸入是 0,擰它什麼也改變不了,偏導數就是 0。
這其實是複合函式求導的一個特例,叫鏈式法則:損失透過 依賴 ,那麼“ 變一點,損失變多少”就等於“ 變一點, 變多少”乘上“ 變一點,損失變多少”。中間隔了好幾層也是一樣,把每一層的變化倍數依次乘起來。像一串齒輪,第一個轉一圈,最後一個轉幾圈,就等於沿途各級傳動比相乘。
有了這幾樣工具,就可以開啟那個 10 個引數的 Transformer 了。
二、一個能手算的 Transformer
任務:說出第一個字
先說清楚 Transformer 在做什麼。它是今天大語言模型的基本結構,乾的事情是“看前面的字,猜下一個字”。我們給它一個小到不能再小的任務:字只有 A 和 B 兩個,模型每次讀兩個字,讀到第二個字時,說出第一個字是什麼。一共只有四種輸入:
- AA → A,AB → A,BA → B,BB → B。
為什麼挑這個任務?因為模型站在第二個位置上做預測,手裡直接拿著的是第二個字,要答對就必須回頭看第一個字。“該看哪裡”正是 Transformer 裡注意力負責的事;訓練好的大模型裡,也確實有專門負責“看前一個字”的注意力1。
一個完整的 Transformer 還有很多別的部件2,我們只留下注意力和最後把結果變成答案的輸出層,其餘全部去掉。
字怎樣變成數
電腦只能處理數,所以每個字先變成三個數。A 記作 ,B 記作 :第一個數表示“是不是 A”,第二個數表示“是不是 B”。第三個數是一個位置標記,只有正在做預測的第二個位置上是 1,相當於告訴模型“這是我自己”。
所以輸入 BA 變成兩組數:第一個位置 ,第二個位置 。這一步是固定的,不參與訓練。
注意力:先打分,再分配比例
注意力要決定兩個位置各看幾成。它分三步。
第一步,提問和亮牌。 第二個位置提出一個“問題”,叫查詢,記作 ;每個位置各亮出一張“牌”,叫鍵,記作 、。它們都是用引數和輸入算出來的一個數:查詢用三個引數 ,鍵用另外三個引數 ,演算法都是“對應位置相乘,再加起來”。比如第二個位置的鍵:
第二步,打分。 查詢和每張牌相乘,得到兩個分數 ,。分數越高,越該看那個位置。
第三步,把分數變成比例。 兩個分數要變成兩個加起來等於 1 的比例 、,表示第一個位置看幾成、第二個位置看幾成。用的辦法叫 softmax:先對每個分數取 的冪,變成正數,再各自除以總和。
為什麼用 的冪?因為它永遠是正的,分數高的分到的比例就大,而且它的導數就是它自己,後面求導時很方便。
輸出:看到了什麼,就說什麼
按比例把兩個字混在一起:看到的東西里,A 佔 ,B 佔 。BA 這個例子裡,第一個字是 B、第二個字是 A,所以 ,。
輸出層用四個引數 給 A、B 兩個答案打分:
兩個分數再用一次 softmax,變成“答 A”和“答 B”的機率 、。
要訓練的引數就是 的 3 個、 的 3 個、 的 4 個,一共 10 個。初值我們挑了好算的:;,;,另外兩個是 0。真實的訓練從隨機的小數出發,我們手挑初值,是為了讓數字整齊,並且讓模型一開始是錯的。
三、前向:從輸入算到損失
一個樣本走一遍
從輸入一路算到答案,叫前向計算。拿 BA 來算,正確答案是 B。
查詢:。鍵:第一個位置是 B,;第二個位置是 A 加位置標記,。分數 ,。
softmax:,,加起來 2.649,所以 ,。模型把六成多的注意力放在了第二個字,也就是它自己身上,看錯了地方。原因在 :它是 0.5,給帶著“我自己”標記的那個位置加了分。
看到的東西:,,六成是 A。輸出分數 ,。再用 softmax:,。模型更傾向於說 A,答錯了(圖 2)。
損失:為什麼用 −ln p
熱身裡的損失是“差值的平方”。這裡的答案是一個字,沒有“差多少”可言,用什麼當損失?
最直覺的是數一數答對了幾道。可這個數沒法用來訓練:把某個引數從 0.5 改成 0.51, 從 0.469 變成 0.470,答案還是 A,答對的題數一道沒變,導數是 0。分數對小的改動毫無反應,就給不出“該往哪邊擰”的資訊。
所以實際用的是交叉熵損失:
是以 為底的對數。BA 的損失是 。它有幾個好記的點:正確答案的機率是 1 時,;是 0.5,也就是瞎猜時,;機率越接近 0, 越大,沒有上限。 每多一點,損失就少一點,哪怕答案還沒翻過來。
另外三個樣本也這樣算。AA 和 BB 兩個字相同,不管注意力放在哪裡,看到的都是同一個字,正確答案的機率是 0.622,損失 0.474;AB 和 BA 情況對稱,損失也是 0.756。四個數取平均:,這就是開頭打出來的第一個數。
現在的問題和熱身一樣:10 個旋鈕,各該往哪邊擰、擰多少,才能讓 0.615 變小?
四、梯度:每個引數往哪邊調
第一次嘗試:挨個動一下
不會求導也有辦法:一個一個試。把 從 0.5 調到 0.51,其餘不動,重新算一遍 BA 的損失,0.7563 變成了 0.7542,少了 0.0020。改動 0.01,損失變了 −0.0020,兩者之比是 −0.200。這個比值就是 的近似值:負的,說明 該調大。
再試 :從 0.5 調到 0.51,損失多了約 0.00125,比值 +0.125,說明它該調小,和前面“它讓模型看錯了地方”的判斷一致。把 在一段範圍裡來回掃,畫出損失的樣子(圖 3),跟熱身的拋物線是一回事:損失是一條光滑的曲線,偏導數就是當前這一點的斜率。
圖 3 還說明了一件事:就算把 調到很負、注意力全放在第一個字上,BA 的損失也只降到 0.474,因為輸出層的 0.5 太小,答得不夠果斷。要把損失降下去,“看哪裡”和“說什麼”兩頭都得改,10 個引數要一起動。
不足:引數一多就試不動
挨個試,每個引數都要多算一兩次前向。10 個引數還算得過來;GPT-3 有 1750 億個引數,挨個試一遍,就要算 3500 億次前向,而這隻夠走一步。
有沒有辦法算一趟,就得到所有引數的偏導數?
五、反向傳播:從損失往回算
思路:沿途的倍數相乘
熱身裡的鏈式法則說,隔了好幾層,就把每層的變化倍數乘起來。 影響損失的路線是: 改變鍵 , 改變分數 ,分數改變比例 ,比例改變看到的 , 改變輸出分數 ,最後 改變損失。
關鍵在於,靠近損失的那幾段路是很多引數共用的。10 個引數都要經過“ 怎樣影響 ”這一段;6 個注意力引數還要共同經過 、、。所以從損失出發往回走,每走一層,就把“損失對這一層的導數”記下來,下一層直接拿來乘。一趟走完,所有引數的偏導數就都有了。這就是反向傳播3,它的計算量和一次前向差不多,大約是兩倍,跟引數有多少個無關。
下面沿著圖 2 的箭頭倒著走一遍。每一步只用到熱身裡那兩件事:求導,以及倍數相乘。
逐層往回
第一步:輸出分數。 只有兩個答案時,。把損失 寫開,再分別對 、 求導,能得到一個很乾淨的結果:
(推導:,對 求導得 ,對 求導得 。)讀法很直接:A 的分數應該降,B 的分數應該升,力度就是模型離正確答案差多遠。
第二步:輸出層的四個引數。 ,正是熱身裡那種“引數乘輸入”的形狀。用那條規律,偏導數等於“傳回來的導數 × 這個引數乘著的輸入”:
- :;:;
- :;:。
的 −0.200,正好就是前面挨個試出來的那個數。
第三步:看到的東西和注意力比例。 同時出現在 和 裡,兩條路的影響要加起來:;同理 。看到的 A 多了不好,B 多了好。在 BA 裡 、,所以 ,:多看第一個字會讓損失變小。
第四步:穿過 softmax。 兩個比例加起來恆等於 1,一個漲另一個就跌,不能分開算。只有兩個位置時,,求導可以得到: 每增加一點, 增加 倍, 減少同樣多。所以
正好相反,是 +0.125。 這個倍數值得記住:比例是 0.5 和 0.5 時它最大,是 0.25;如果注意力幾乎全壓在一邊,比如 0.999 和 0.001,它就接近 0,梯度傳到這裡就過不去了。第九節會遇到這種情況。
第五步:查詢和鍵。 ,對 求導是 ,對 求導是 。所以 ;,。
第六步:落到 6 個注意力引數上。 又是“傳回來的導數 × 輸入”。,所以 和 的偏導數都是 0.062, 乘著的輸入是 0,偏導數是 0。,,所以 的偏導數是 −0.125, 和 都是 0.125。 的 0.125,正是前面試出來的那個坡度。
一趟走下來,10 個偏導數全部到手(圖 4),每一步都只是求導和乘法。
對賬
手算難免出錯,我們用兩種辦法核對4。一是前面那種“挨個動一下”,10 個數和手算的結果在四位小數上全部一致。二是交給 PyTorch,一個常用的深度學習工具,它能自動做反向傳播。下面這段程式碼可以跳過,只看輸出:
import torchx1 = torch.tensor([0., 1., 0.]) # B,第 1 个位置x2 = torch.tensor([1., 0., 1.]) # A,第 2 个位置(带“我自己”标记)wq = torch.tensor([0.5, 0.5, 0.5], requires_grad=True)wk = torch.tensor([0.0, 0.0, 0.5], requires_grad=True)Wo = torch.tensor([[0.5, 0.0], [0.0, 0.5]], requires_grad=True)
q = wq @ x2k = torch.stack([wk @ x1, wk @ x2])a = torch.softmax(q * k, dim=0)h = a[0] * x1[:2] + a[1] * x2[:2]z = Wo @ hloss = torch.nn.functional.cross_entropy(z[None], torch.tensor([1]))loss.backward()print(loss.item(), wq.grad, wk.grad, Wo.grad, sep="\n")0.756250262260437tensor([0.0623, 0.0000, 0.0623])tensor([ 0.1247, -0.1247, 0.1247])tensor([[ 0.3303, 0.2003], [-0.3303, -0.2003]])和手算的一樣。loss.backward() 那一行,做的就是第一步到第六步。
六、更新:沿著下坡走一步
一步更新
有了 10 個偏導數,更新和熱身裡一模一樣:每個引數減去學習率乘它的偏導數。先只用 BA 這一個樣本、取學習率 1 走一步(表 2)。
| 引數 | 原值 | 梯度 | 新值 |
|---|---|---|---|
| w_q₁(A) | 0.5 | 0.062 | 0.438 |
| w_q₂(B) | 0.5 | 0 | 0.5 |
| w_q₃(當前位置) | 0.5 | 0.062 | 0.438 |
| w_k₁(A) | 0 | 0.125 | −0.125 |
| w_k₂(B) | 0 | −0.125 | 0.125 |
| w_k₃(當前位置) | 0.5 | 0.125 | 0.375 |
| W_AA | 0.5 | 0.330 | 0.170 |
| W_AB | 0 | 0.200 | −0.200 |
| W_BA | 0 | −0.330 | 0.330 |
| W_BB | 0.5 | −0.200 | 0.700 |
梯度保留三位小數,新值按未舍入的梯度算。
用新引數把 BA 重新算一遍:注意力 從 0.378 升到 0.473, 從 0.469 升到 0.625,損失從 0.756 降到 0.470。模型對 BA 的答案翻了過來,從說 A 變成了說 B。
現象:BA 變好了,別的樣本變差了
但再看看另外三個樣本(表 3)。
| 樣本 | 走之前 | 走之後 |
|---|---|---|
| AA → A | 0.474 | 0.777 |
| AB → A | 0.756 | 1.061 |
| BA → B | 0.756 | 0.470 |
| BB → B | 0.474 | 0.341 |
BA 自己:a₁ 從 0.378 升到 0.472,p_B 從 0.469 升到 0.625。
AA 的損失從 0.474 漲到 0.777,答案也從對變成了錯。原因要回到表 2:變化最大的不是注意力的引數,而是輸出層。對 BA 這一個樣本來說,最快的下坡路是“不管看到什麼,都多說 B”:B 那一行的兩個引數調大,A 那一行調小。這條路比把注意力扭過來陡得多(輸出層的偏導數是 0.330、0.200, 只有 0.125),可它對 AA、AB 是壞事。
一個樣本算出來的坡度,只是這一個樣本的坡度。怎樣讓一步對所有樣本都有好處?
七、一批樣本:把梯度平均
四個樣本各說各的
訓練真正要降的是四個樣本的平均損失。平均數的導數就是導數的平均,所以把四個樣本的偏導數各自算出來,再取平均就行。把它們並排放在一起(表 4),能看出各個樣本在“想”什麼。
| 引數 | AA | AB | BA | BB | 平均 |
|---|---|---|---|---|---|
| w_q₁(A) | 0 | 0 | 0.062 | 0 | 0.016 |
| w_q₂(B) | 0 | 0.062 | 0 | 0 | 0.016 |
| w_q₃(當前位置) | 0 | 0.062 | 0.062 | 0 | 0.031 |
| w_k₁(A) | 0 | −0.125 | 0.125 | 0 | 0 |
| w_k₂(B) | 0 | 0.125 | −0.125 | 0 | 0 |
| w_k₃(當前位置) | 0 | 0.125 | 0.125 | 0 | 0.062 |
| W_AA | −0.378 | −0.200 | 0.330 | 0 | −0.062 |
| W_AB | 0 | −0.330 | 0.200 | 0.378 | 0.062 |
| W_BA | 0.378 | 0.200 | −0.330 | 0 | 0.062 |
| W_BB | 0 | 0.330 | −0.200 | −0.378 | −0.062 |
AA 和 BB 兩個字一樣,看哪個位置取到的都是同一個字,所以對 w_q、w_k 的梯度全是 0。
AA 和 BB 對 6 個注意力引數的偏導數全是 0:兩個字一樣,看哪裡都一樣,它們對注意力沒有意見,只希望輸出層更果斷地“看到什麼就說什麼”。
AB 和 BA 在 、 上意見正好相反。BA 希望 A 的牌小一點、B 的牌大一點(這樣會多看第一個字 B),AB 希望的正好反過來。平均後兩者抵消成 0,這是好事:“A 的牌比 B 小”並不是這個任務的規律,只照顧一個樣本才會學到它。
它們在 上意見一致,都是 +0.125,平均後是 0.062。四個樣本唯一的共識是:把“我自己”這張牌壓低,讓模型少看自己。這正是這個任務真正的規律。
平均之後走一步
用平均梯度走一步(學習率還是 1): 從 0.5 降到 0.438,、 從 0.5 升到 0.562,另外兩個從 0 降到 −0.062。四個樣本里,AA 和 BB 的損失從 0.474 降到 0.429,AB 和 BA 卻從 0.756 微微漲到 0.759,平均損失從 0.615 降到 0.594,這就是開頭的第二個數。
為什麼難的兩個樣本反而略差?因為這一步主要加強的是輸出層的“照抄”:看到什麼就更果斷地說什麼。可 AB、BA 這時看的還主要是自己( 只有 0.397),照抄得越果斷,錯得越果斷。平均梯度保證的是平均損失下降,不保證每個樣本都變好。
真實訓練的樣本有成千上萬,不可能每一步都全部算一遍,於是每一步隨機抽一小批來算平均梯度,這叫隨機梯度下降。一小批的平均只是全體平均的估計,有點偏差,但方向大體是對的,代價卻小得多。
八、多步:從平臺到收斂
現象:難的樣本先停在原地,然後突然下降
一直這樣走下去,前 40 步的情況畫在圖 5 裡。
前 6 步,AA、BB 的損失從 0.474 降到 0.260,AB、BA 卻幾乎原地不動,0.756、0.759、0.755……到第 6 步才到 0.687。這段時間裡並非什麼都沒發生: 每一步都在往下走,0.5、0.438、0.362、0.275……第 6 步降到 −0.028,變成負數;注意力 跟著從 0.378 慢慢爬到 0.505,越過了一半。
越過一半之後,情況反過來了。模型看到的東西里第一個字佔了多數,輸出層那份“照抄”的果斷從幫倒忙變成了幫忙,兩件事互相放大:第 10 步 AB、BA 的損失是 0.504,第 16 步已經是 0.146。開頭那串數里,第 10 步 0.336、第 20 步 0.076,降得最快的就是這一段。
再往後,曲線變得很平。10 個偏導數整體的大小(平方和再開方)在第 11 步最大,是 0.228;到第 50 步只有 0.023,第 200 步只剩 0.005。坡越來越緩,每一步挪得越來越少,就像熱身裡越靠近谷底步子越小。損失從 0.030(第 40 步)慢慢挪到 0.005(第 200 步)。走到這樣一片坡度很小、每步幾乎不動的地方,就叫收斂。
收斂到了什麼
走了 200 步以後,,、 約 0.99, 約 1.48,、 是 2.91,另外兩個是 −2.41。
把它們代回模型就能讀出它學會的規則。查詢 ,是個正數;第一個字的牌是 0,第二個字因為帶著“我自己”標記,牌是 −1.94。分數一個是 0、一個是 ,softmax 之後 。也就是說,模型學會了“別看自己,看前一個字”,再用輸出層把看到的字照抄出來。這條規則沒有人寫過,是四個樣本的梯度一步步推出來的。
損失永遠不會恰好是 0:要 正好等於 1 才行,而 softmax 給不出正好的 1,引數只能越來越大地逼近它。真實訓練也不會等到“完全收斂”,而是在預算用完、或者在沒見過的資料上的成績不再變好時停下。
走到的這個地方也不是唯一的。我們換掉手挑的初值,讓 10 個引數從隨機數出發,跑了 100 次,每次都在 20 到 37 步之內把平均損失降到 0.05 以下,一次也沒有失敗;可最後的引數各不相同,光是 就散佈在 −1.82 到 1.77 之間。 是正數的那些解,查詢恰好是負數,負負得正,同樣做到了“別看自己”。梯度下降找到的不是“那個”最優解,而是一大片同樣好的解裡離起點比較近的一個4。
還有一個數是我們隨手定的:學習率為什麼取 1?
九、學習率:步子邁多大
現象:大了更快,再大就卡死
同一個起點,換四種學習率各跑 60 步(圖 6)。
0.1 太小,60 步後平均損失還有 0.469,要兩百步左右才能到 0.08。學習率 10 反而最快,3 步就降到 0.031。可一旦加到 30,事情就壞了:第 1 步損失從 0.615 漲到 0.714,第 2 步 0.914,第 3 步跳到 3.79,然後再也下不來。
原因:一步跨過了谷底
熱身裡已經見過前一半:步子太大,就會跨過谷底,跳到另一邊去。這裡還多了一件更糟的事。
學習率 30 的第 2 步, 一下變成 7.56,三個查詢引數變成 15.2、15.2、30.0。這時 BA 第二個位置的分數是 341,第一個位置是 0,softmax 給出的比例是 :模型只看自己。
還記得反向傳播第四步裡的那個倍數 嗎?現在它是 0。損失再怎麼變,傳到分數這裡都乘上了 0,6 個注意力引數再也收不到任何訊號,注意力永遠轉不回來。剩下的輸出層只能看到第二個字,而第二個字和答案無關,它最好的做法是兩個字各給一半機率;可是學習率太大,它每一步都衝過頭,在兩邊來回翻,損失就停在 3.7 上下。
這也是大模型訓練裡很多做法的來由。GPT-3 的學習率只有 0.00006,開始時還要從 0 慢慢升上去,後面再逐漸降低;偏導數整體太大時,還會按比例縮小再用5。這些手段都是為了不讓某一步邁得太遠,掉進坡度為 0、再也走不出來的地方。
十、放大到真實的 Transformer
我們的模型和 GPT-3 走的是同一套流程:前向算損失,反向算梯度,減一步,重複。差別在下面這張表裡。
| 專案 | 本文 | GPT-3 |
|---|---|---|
| 引數 | 10 | 1750 億 |
| 結構 | 一層注意力,查詢和鍵各是 1 個數 | 96 層,每層 96 組注意力,查詢和鍵各是 128 個數 |
| 其他部件 | 沒有 | 每層還有一個小網路和幾處幫助訓練穩定的結構;字怎樣變成數也參與訓練 |
| 一步用的題目 | 4 道 | 約 320 萬道 |
| 訓練資料 | 4 道題反覆用 | 約 3000 億個詞元 |
| 求梯度 | 手算,再用工具核對 | 工具自動做反向傳播 |
| 更新規則 | 引數減去學習率乘偏導數 | 同樣的思路,但每個引數有自己的步長 |
| 學習率 | 1 | 0.00006 |
GPT-3 的數字取自論文表 2.1 和附錄 B。詞元是模型處理文字的單位,一個詞元大致是一個英文單詞或一兩個漢字。
幾處差別值得多說一句。
每個位置都是一道題。 我們的模型只在第二個位置答題;語言模型在每個位置都猜下一個詞元,一段 2048 個詞元的文字就是 2048 道題,損失是所有題目的平均。所以“一步 320 萬道題”就是一步平均了這麼多道題的梯度。用 3000 億除以 320 萬粗算,GPT-3 一共走了九萬多步。
多出來的部件,大多是為了讓梯度傳得動。 我們的梯度往回只走了六步,96 層的模型要往回走幾百步,一路連乘,很容易乘到接近 0,或者大得離譜。所以真實的 Transformer 給梯度留了一條可以直通的近路,還在每層把數值拉回固定範圍,FPGA 那篇講過這一點。至於每一步反向傳播本身,做的仍然是第五節那幾件事:求導,乘上傳回來的導數。
每個引數有自己的步長。 我們的做法裡,10 個引數共用一個學習率,偏導數大的步子就大;輸出層就是因此先跑在了注意力前面。GPT-3 用的方法叫 Adam,它記著每個引數最近的偏導數有多大,按這個調整各自的步長,讓偏導數一直很小的引數也能走得動6。所以它的學習率和我們這裡的“1”不能直接比大小。
十一、與現實中的最佳化問題相比
現象:現實裡找最優解很難,這裡卻很順
現實世界裡,找一個問題的最優解往往很難。一個麵包配方要烤出來嚐了才知道好不好,一種藥要做完實驗才知道有沒有效,一張課表的排法多到排不完。可在 Transformer 裡,1750 億個引數,靠熱身裡那個簡單的規則,一步步就走到了很低的地方。為什麼這裡就這麼順?
先要糾正一點:Transformer 找到的並不是最優解。第八節的 100 次隨機起點各自停在了不同的地方;GPT-3 訓練結束時的損失也遠不是 0。訓練要的只是“足夠低”,而足夠低的地方有很多。不過現實中很多問題也只要求夠好,就算只求夠好依然很難。所以差別不在目標,而在找解的條件上。
原因:坡度是不是現成的
第四節那個“挨個動一下”的辦法,其實就是現實中找解的常態。不知道配方和口味之間的公式,就只能改一點、烤一爐、嘗一口,只看結果,不知道坡度,這叫黑箱最佳化。Transformer 的損失是我們自己寫出來的公式,每一步運算都能求導,反向傳播一趟就把所有引數的坡度一起算出來。
這個差別在小問題上看不出來。我們讓一個只看損失值的隨機搜尋去解本文那個 10 個引數的問題:每次隨機改幾個引數,變好就留下,變差就退回。從同一個初值出發跑 20 次,中間那一次用了 77 次計算,就把平均損失降到 0.05 以下;梯度下降要 27 步,每步一次前向加一次反向,大約相當於 81 次前向。兩者差不多。
把同一個任務放大,差距才顯出來(表 6)。字從 2 個加到 64 個,序列也一樣長,引數從 36 個增加到 5120 個。隨機搜尋這一邊換成更聰明的版本,步子會根據成敗自動調整;梯度這一邊用 Adam。
| 引數個數 | 梯度:步數 | 梯度:摺合前向次數 | 黑箱:評估次數 |
|---|---|---|---|
| 36 | 32 / 29 / 37 | 96 / 87 / 111 | 55 / 37 / 28 |
| 80 | 48 / 47 / 43 | 144 / 141 / 129 | 180 / 97 / 96 |
| 192 | 69 / 69 / 65 | 207 / 207 / 195 | 337 / 356 / 393 |
| 512 | 88 / 87 / 86 | 264 / 261 / 258 | 648 / 685 / 844 |
| 1,536 | 137 / 105 / 195 | 411 / 315 / 585 | 3,695 / 1,482 / 失敗 |
| 5,120 | 368 / 243 | 1,104 / 729 | 失敗 / 失敗 |
梯度一步按 3 次前向折算。黑箱上限 30 萬次評估,“失敗”是用完 30 萬次仍未達標。
只有 36 個引數時,隨機搜尋反而比梯度省;到 192 個引數,它已經要多花一倍;到 5120 個引數時,梯度兩次分別用了 368 步和 243 步,隨機搜尋兩次都用完了 30 萬次計算,損失停在 0.667 和 0.113,沒有達標。梯度需要的步數隨引數增加漲得很慢,因為每一步都同時拿到所有引數的方向;隨機搜尋每次只能知道一個“好還是不好”,引數越多,碰巧改對的機會越小,需要的次數大致跟著引數個數漲,還會卡在半路下不來。照這個趨勢推到 1750 億個引數,隨機搜尋毫無希望。現實中的問題還要再乘上一次試驗的代價:這裡一次前向不到一毫秒,可烤一爐麵包要一小時,做一輪藥物實驗要幾個月。
另外兩個條件:試錯便宜,引數連續
試錯便宜、可重複、能撤回。 一次前向在電腦裡算,結果完全確定,算錯了把引數改回去就行,可以重複億萬次。現實中的試錯有誤差,要花時間和錢,有的還不可逆。這並不是說訓練不花代價:GPT-3 的訓練用了約 3×10²³ 次浮點運算,只是這些代價交給了機器,而且能拆成無數個可以同時進行的小步驟。
引數是連續的,好解連成一片。 課表、路線、電路開關這類問題,變數只能一格一格地換,換一格結果就跳一下,坡度無從談起,FPGA 那篇講的就是這件事。Transformer 的引數可以取任意小數,每一步運算都能求導,損失隨引數平滑變化;引數又遠多於“恰好夠用”,前面 100 次隨機起點都能走到低處,靠的就是這一點。
反過來看
現實中的問題一旦湊齊這些條件,同樣可以用梯度來解。工程師設計機翼、橋樑結構或者光學鏡片的形狀時,會把物理過程寫成能求導的計算,一次算出目標對成千上萬個設計引數的導數,它和反向傳播是同一類計算。
Transformer 裡湊不齊這些條件的部分,也就和現實一樣難。模型要多少層、學習率取多少、訓練資料怎麼搭配,這些都沒有導數可求,只能一次一次地試,而試一次就是完整訓練一個模型。本文的學習率 1、10、30 就是試出來的;GPT-3 的論文同時訓練了 8 個大小不同的模型5,大模型團隊普遍先在小模型上把這些選擇試好,再放大到大模型。
所以,不是 Transformer 裡的問題天生簡單,而是人們把它造成了梯度能解的樣子:損失寫得出公式,每一步都能求導,計算便宜到可以重複億萬次。難的部分並沒有消失,它轉到了“怎樣把問題造成這個樣子”上。
十二、回到開頭
現在可以把開頭那串數逐行讀一遍了。它就是下面這段程式碼跑出來的,同樣可以跳過程式碼,只看後面的解釋4:
import torchemb = {"A": [1., 0, 0], "B": [0, 1., 0]}X = torch.tensor([[emb[s[0]], [a + b for a, b in zip(emb[s[1]], [0, 0, 1.])]] for s in ["AA", "AB", "BA", "BB"]])Y = torch.tensor([0, 0, 1, 1]) # 目标:第一个字
wq = torch.tensor([0.5, 0.5, 0.5], requires_grad=True)wk = torch.tensor([0.0, 0.0, 0.5], requires_grad=True)Wo = torch.tensor([[0.5, 0.0], [0.0, 0.5]], requires_grad=True)opt = torch.optim.SGD([wq, wk, Wo], lr=1.0)
def model(X): q = X[:, 1] @ wq # 每个样本一个查询(第 2 个位置) k = X @ wk # 每个位置一个键 a = torch.softmax(q[:, None] * k, dim=1) # 注意力比例 h = (a[:, :, None] * X[:, :, :2]).sum(1) # 按比例混合看到的字 return h @ Wo.T # 两个答案的分数
for step in range(41): loss = torch.nn.functional.cross_entropy(model(X), Y) if step in (0, 1, 2, 3, 10, 20, 40): print(f"step {step:2d} loss {loss.item():.3f}") opt.zero_grad() loss.backward() opt.step()第 0 步的 0.615,是四個樣本損失 0.474、0.756、0.756、0.474 的平均。loss.backward() 算出的是表 4 最後一列那 10 個平均偏導數,opt.step() 把它們乘上學習率 1 從引數裡減掉,於是第 1 步變成 0.594,其中 AA、BB 變好了,AB、BA 還略差一點。第 2、3 步的 0.572、0.548 降得慢,是因為注意力還在慢慢轉,出力的主要是輸出層。第 10 步的 0.336 和第 20 步的 0.076 之間降得最快,那是注意力越過一半之後,“看對地方”和“照抄看到的字”互相放大的階段。第 40 步的 0.030 之後,坡已經很緩,模型基本學會了“看前一個字”。
小結
- 訓練在做什麼? 把一個叫損失的數擰小。損失要對引數的每一點變化都有反應,才算得出坡度:“答對幾道”不行,交叉熵 可以。
- 梯度下降是什麼? 算出損失對每個引數的偏導數,也就是坡度,每個引數減去學習率乘它的偏導數,重複。一個旋鈕時,它就是沿著拋物線一步步走到谷底。
- 反向傳播做了什麼? 從損失往回,把沿途每一層的變化倍數依次相乘,一趟算出所有引數的偏導數,不用挨個去試。最常用的一條:引數的偏導數等於傳回來的導數乘上它乘著的輸入,輸入是 0,偏導數就是 0。
- 為什麼要一批樣本一起算? 只按一個樣本走,會學到只對它有用的捷徑;按一批樣本的平均走,互相矛盾的意見抵消,剩下的是共同的規律。
- 為什麼要走很多步,曲線為什麼先平後陡? 坡度只在腳下可靠,所以每次只走一小步。注意力沒轉過來之前,難的樣本幾乎不動;越過一半以後,“看哪裡”和“說什麼”互相放大,損失迅速下降;之後坡越來越緩,這就是收斂。
- 學習率為什麼要小心? 太小走得慢,太大會跨過谷底,甚至跳進坡度為 0 的地方再也出不來。
- 為什麼這裡找解比現實中容易? 找到的不是唯一的最優解,而是一大片好解裡的一個;更關鍵的是,損失是寫出來的公式,一趟反向傳播就拿到所有引數的坡度,試錯又便宜。只看結果的隨機搜尋,代價隨引數個數上漲,到大模型的規模就完全走不動。現實問題湊齊這些條件也能用梯度解;Transformer 裡湊不齊的部分,比如層數和學習率,也只能靠試。
參考資料
參考資料
-
In-context Learning and Induction Headstransformer-circuits.pub ↗訓練好的 Transformer 裡有專門“看前一個詞元”的注意力頭(previous token head),它和後面的歸納頭配合完成複製。https://transformer-circuits.pub/2022/in-context-learning-and-induction-heads/index.html ↩
-
Attention Is All You Needarxiv.org ↗Transformer 的原始論文。注意力打分除以 √d_k 的做法見第 3.2.1 節。https://arxiv.org/abs/1706.03762 ↩
-
Learning representations by back-propagating errorsdoi.org ↗https://doi.org/10.1038/323533a0 ↩
-
本文的實驗指令碼與日誌專案共享目錄
gradient-descent-research/:experiment/tiny.py是模型和手寫的反向傳播,walk.py列印 BA 一步的全部中間值,batch.py是四個樣本的梯度和多步軌跡,torch_check.py、train_torch.py用 PyTorch 自動求導對賬,build_figs.py生成文中的圖和表。 ↩ ↩2 ↩3 -
Language Models are Few-Shot Learnersarxiv.org ↗表 2.1:175B 模型 96 層、d_model 12288、96 個頭、每頭 128 維,批大小 320 萬詞元,學習率 0.6×10⁻⁴,共訓練 3000 億詞元。附錄 B:Adam(β₁ = 0.9,β₂ = 0.95),梯度全域性範數裁剪到 1.0,前 3.75 億詞元線性預熱,之後 2600 億詞元內餘弦衰減到 10%。表 D.1:訓練總計算量 3.14×10²³ 次浮點運算;論文同時訓練了從 1.25 億到 1750 億引數的 8 個模型。https://arxiv.org/abs/2005.14165 ↩ ↩2
-
Adam: A Method for Stochastic Optimizationarxiv.org ↗https://arxiv.org/abs/1412.6980 ↩