AAAWgmp1bWIAAAAeanVtZGMycGEAEQAQgAAAqgA4m3EDYzJwYQAAABZcanVtYgAAAEdqdW1kYzJtYQARABCAAACqADibcQN1cm46YzJwYToyNzQ2MzEwNC0wYWY5LTRhNWYtYTViNi1hNmRiYWY0YTQ2MTYAAAADl2p1bWIAAAApanVtZGMyYXMAEQAQgAAAqgA4m3EDYzJwYS5hc3NlcnRpb25zAAAAALxqdW1iAAAARGp1bWRjYm9yABEAEIAAAKoAOJtxE2MycGEuaW5ncmVkaWVudC52MwAAAAAYYzJzaK0pHSemwVWlVPB9nOGw2d4AAABwY2JvcqNpZGM6Zm9ybWF0bWltYWdlL3N2Zyt4bWxqaW5zdGFuY2VJRHgseG1wOmlpZDpmYjhkNmU4Mi02OTM0LTRjMDMtYmFhOC05MzdkOThjYzkyZjZscmVsYXRpb25zaGlwaHBhcmVudE9mAAAB4mp1bWIAAABBanVtZGNib3IAEQAQgAAAqgA4m3ETYzJwYS5hY3Rpb25zLnYyAAAAABhjMnNolwGrFFfaWQ7w0ULAobxPSQAAAZljYm9yomdhY3Rpb25zgqJmYWN0aW9ua2MycGEub3BlbmVkanBhcmFtZXRlcnOha2luZ3JlZGllbnRzgaJjdXJseC1zZWxmI2p1bWJmPWMycGEuYXNzZXJ0aW9ucy9jMnBhLmluZ3JlZGllbnQudjNkaGFzaFggPvjZuA2CGTUwG3pw4/h0tFYCT3/+/6laCufScdGByimkZmFjdGlvbngdY29tLmFudGhyb3BpYy5jbGF1ZGUucHJvdmlkZWRqcGFyYW1ldGVyc6F4H2NvbS5hbnRocm9waWMub3JpZ2luLWNvbmZpZGVuY2VndW5rbm93bmtkZXNjcmlwdGlvbnhmQ2xhdWRlIHByb3ZpZGVkIHRoaXMgZmlsZSBhdCB0aGUgcmVxdWVzdCBvZiBhIHVzZXIgYW5kIG1heSBoYXZlIGNyZWF0ZWQgb3IgbW9kaWZpZWQgdGhlIGZpbGUgY29udGVudHMubXNvZnR3YXJlQWdlbnShZG5hbWVmQ2xhdWRlcmFsbEFjdGlvbnNJbmNsdWRlZPUAAADIanVtYgAAAEBqdW1kY2JvcgARABCAAACqADibcRNjMnBhLmhhc2guZGF0YQAAAAAYYzJzaLvvfFNb8fk8vH4PoKjjBsYAAACAY2JvcqVjYWxnZnNoYTI1NmNwYWRNAAAAAAAAAAAAAAAAAGRoYXNoWCBvNy3huoBx853wBKbzvkvSVrxTmYb2G9JjLtKQ5svE12RuYW1lbmp1bWJmIG1hbmlmZXN0amV4Y2x1c2lvbnOBomVzdGFydBj4Zmxlbmd0aBkeBAAAAj5qdW1iAAAAJ2p1bWRjMmNsABEAEIAAAKoAOJtxA2MycGEuY2xhaW0udjIAAAACD2Nib3KlY2FsZ2ZzaGEyNTZpc2lnbmF0dXJleE1zZWxmI2p1bWJmPS9jMnBhL3VybjpjMnBhOjI3NDYzMTA0LTBhZjktNGE1Zi1hNWI2LWE2ZGJhZjRhNDYxNi9jMnBhLnNpZ25hdHVyZWppbnN0YW5jZUlEeCx4bXA6aWlkOjE5MjgwYTg0LTM2OTItNDRlNS1iZWUzLTcyOGRmNzE3NzJjY3JjcmVhdGVkX2Fzc2VydGlvbnODomN1cmx4LXNlbGYjanVtYmY9YzJwYS5hc3NlcnRpb25zL2MycGEuaW5ncmVkaWVudC52M2RoYXNoWCA++Nm4DYIZNTAbenDj+HS0VgJPf/7/qVoK59Jx0YHKKaJjdXJseCpzZWxmI2p1bWJmPWMycGEuYXNzZXJ0aW9ucy9jMnBhLmFjdGlvbnMudjJkaGFzaFggjWr+C+xhu14UftlEQvMlBG6GFnPsk5wv7llMys/eDwOiY3VybHgpc2VsZiNqdW1iZj1jMnBhLmFzc2VydGlvbnMvYzJwYS5oYXNoLmRhdGFkaGFzaFggr/LL3475ArhE2oAXn6aQOUeanxg6kxdbdtnTd17+54t0Y2xhaW1fZ2VuZXJhdG9yX2luZm+jZG5hbWVvQW50aHJvcGljIEZpbGVzZ3ZlcnNpb25lMS4wLjBrc3BlY1ZlcnNpb25lMi40LjAAABA4anVtYgAAAChqdW1kYzJjcwARABCAAACqADibcQNjMnBhLnNpZ25hdHVyZQAAABAIY2JvctKEWQISogEmGCFZAgowggIGMIIBjaADAgECAhRA5aAK7sI50L64g/oGQgU9Z1UTADAKBggqhkjOPQQDAzBJMRcwFQYDVQQKEw5BbnRocm9waWMsIFBCQzEuMCwGA1UEAxMlQW50aHJvcGljIENvbnRlbnQgQ3JlZGVudGlhbHMgUm9vdCBDQTAeFw0yNjA4MDcxODQzNTZaFw0yODA4MDYxOTQzNTZaMEQxFzAVBgNVBAoTDkFudGhyb3BpYywgUEJDMSkwJwYDVQQDEyBBbnRocm9waWMgQ2xhdWRlIENvbnRlbnQgU2lnbmluZzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABJh6CmvLUBgFFNU0vUKlOVtE6djd17L5SuwX0LemFisBM3dkd/3cyjxFA3Qo5S46fX0/ihY0VZ7mfb9KF703t5OjWDBWMA4GA1UdDwEB/wQEAwIHgDAVBgNVHSUEDjAMBgorBgEEAYPoXgIBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUzlHiBIFOZFsj+OPEz5o+nMHXXMIwCgYIKoZIzj0EAwMDZwAwZAIwMXMdFJ4BetLLVY7ORuE9noqbbAZOZn/aArXyTwFAZfKrPzxF2vPoJNf1+UCdg1XGAjBwX1zd9WGqYkqmL5SFqw1QySjr1zJfpJM9+1rdDwSPLMOPOjKuiXjoU/pUUeG9RwmhY3BhZFkNngAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPZYQOFWh6vbykU7Zc0vOFjeH/VbBq6OMzCvgiq743PdoJTjXpD28uA6+4AEiwjk9y4Jk9w/uSkupnIBaFwdT2nxd2M= 沿著坡度一步步往下走 左邊寫著引數更新公式 w ← w − η·∂L/∂w 和損失從 0.756 降到 0.470。右邊是一條起伏的山谷曲線,一串圓點從左上的山坡沿著曲線一步步走到谷底,每個點旁邊有一小段切線。 每個引數都這樣走一步 w ← w − η·∂L/∂w 樣本 BA 的損失 0.756 一步之後 → 0.470

在《Transformer 和 FPGA 都是電路》裡,我們用一句話概括過模型是怎麼訓練的:先算出“錯誤”對每個引數的坡度,再朝下坡的方向挪一小步。這句話沒錯,但它跳過了所有細節。真正訓練一個模型時,螢幕上看到的是這樣一串數:

step 0 loss 0.615
step 1 loss 0.594
step 2 loss 0.572
step 3 loss 0.548
step 10 loss 0.336
step 20 loss 0.076
step 40 loss 0.030

step 是第幾步,loss 叫作損失,可以先理解成“模型現在錯得有多厲害”。它一步步變小,說明模型越來越對。可是 0.615 是怎麼算出來的?電腦在每一步裡到底做了什麼,才讓它變成 0.594?為什麼前十步降得慢,第十步到第二十步又降得快?

這串數來自一個真的 Transformer,只不過它小到只有 10 個引數。小到這個程度,每一箇中間結果都寫得下。不過在開啟它之前,我們先用一個更小的東西,把“訓練”這件事本身弄清楚。

一、熱身:一個旋鈕

一臺只有一個旋鈕的機器

設想一臺機器,輸入一個數 xx,輸出 y=w⋅xy = w \cdot x。ww 是機器上的一個旋鈕,可以擰到任何讀數。我們希望輸入 2 的時候,輸出是 6。

你當然一眼就看出 ww 應該是 3。但假裝我們不知道,只能從某個讀數開始,比如 w=1w = 1,一點點去擰。神經網路的訓練就是這件事,只不過旋鈕有成千上億個,沒有人能一眼看出答案。

先要有一個數,說明“現在差多遠”。w=1w = 1 時輸出是 2,目標是 6,差了 −4。差值可正可負,我們把它平方,得到一個永遠不小於 0 的數,叫作損失:

L=(2w−6)2L = (2w - 6)^2

w=1w = 1 時 L=16L = 16;擰對了,w=3w = 3,L=0L = 0。訓練的目標就是把 LL 擰小。

導數告訴我們往哪邊擰

LL 是 ww 的二次函式,畫出來是一條開口向上的拋物線,谷底在 w=3w = 3(圖 1)。站在 w=1w = 1 這一點,該往左擰還是往右擰?看腳下的坡就知道了。

坡度就是導數。L=(2w−6)2L = (2w-6)^2 的導數是 L′=2(2w−6)×2=8w−24L' = 2(2w - 6) \times 2 = 8w - 24,w=1w = 1 時等於 −16。負數表示往右是下坡:ww 調大一點,LL 會變小,而且 ww 每增加一點點,LL 大約減少這一點點的 16 倍。

於是規則很簡單:導數是負的就把 ww 調大,是正的就調小,調多少和導數成正比。寫成式子:

w新=w−η×L′(w)w_{\text{新}} = w - \eta \times L'(w)

η\eta 讀作“伊塔”,叫作學習率,管的是一步邁多大。取 η=0.05\eta = 0.05:ww 從 1 變成 1−0.05×(−16)=1.81 - 0.05 \times (-16) = 1.8,損失從 16 降到 5.76。再算一次導數,8×1.8−24=−9.68 \times 1.8 - 24 = -9.6,於是 ww 變成 2.28,損失 2.07。這樣一步步走下去,ww 依次是 2.568、2.741、2.845……越來越接近 3。

一個旋鈕的梯度下降 損失 L = (2w − 6)² 是一條開口向上的拋物線,谷底在 w = 3。從 w = 1 出發,每一步把 w 減去 0.05 乘以當前的斜率,依次走到 1.8、2.28、2.568……一步比一步小,逐漸靠近谷底。 一個旋鈕 · 輸入 2,希望輸出 6,損失 L = (2w − 6)² 0 10 20 0 1 2 3 4 5 6 旋鈕的讀數 w w = 1,L = 16,斜率 −16 w = 1.8,L = 5.76 谷底 w = 3,L = 0 每一步:w 減去 0.05 × 斜率 越靠近谷底,坡越緩,步子越小
圖 1 · 從 w = 1 出發:斜率是負的,就把 w 往大里調;離谷底越近,斜率越小,步子也越小

這就是梯度下降:算坡度,往下坡挪一步,再算坡度,再挪一步。注意步子是越來越小的,因為越靠近谷底,坡越緩,導數越小。

步子邁多大

學習率不能隨便取(表 1)。

同一個起點 w = 1,四種步長走 4 步
學習率w 的變化結果
0.051 → 1.8 → 2.28 → 2.568 → 2.741一步步靠近 3
0.1251 → 3 → 3 → 3 → 3一步到位
0.251 → 5 → 1 → 5 → 1在 1 和 5 之間來回跳
0.31 → 5.8 → −0.92 → 8.488 → −4.683越跳越遠

每一步離谷底的距離都乘上同一個數 1 − 8 × 學習率:0.05 時是 0.6,0.125 時是 0,0.25 時是 −1,0.3 時是 −1.4。

表 1 · 步子太小走得慢,正好合適一步到位,太大就在谷底兩邊來回跳,再大就越跳越遠

這個例子簡單到可以算清原因。新的 ww 減去 3,等於舊的 ww 減去 3 再乘上 1−8η1 - 8\eta。η=0.05\eta = 0.05 時乘的是 0.6,離谷底的距離每步縮到六成;η=0.125\eta = 0.125 時乘的是 0,一步就到;η=0.25\eta = 0.25 時乘的是 −1,從谷底一邊跳到另一邊,距離不變,永遠在 1 和 5 之間來回;η=0.3\eta = 0.3 時乘的是 −1.4,每跳一次離得更遠。導數只說明腳下這一點的坡,步子太大,就會跨過谷底。

兩個旋鈕:偏導數

機器再加一個旋鈕 bb,輸出變成 y=w⋅x+by = w \cdot x + b。輸入還是 2,目標還是 6,損失是 L=(2w+b−6)2L = (2w + b - 6)^2,從 w=1w = 1、b=0b = 0 出發。

現在 LL 同時取決於兩個數。辦法是一次只看一個:先假裝 bb 不動,只對 ww 求導;再假裝 ww 不動,只對 bb 求導。這樣得到的叫偏導數,寫作 ∂L/∂w\partial L / \partial w 和 ∂L/∂b\partial L / \partial b,讀作“L 對 w 的偏導”。

∂L∂w=2(2w+b−6)×2=−16,∂L∂b=2(2w+b−6)×1=−8\frac{\partial L}{\partial w} = 2(2w + b - 6) \times 2 = -16, \qquad \frac{\partial L}{\partial b} = 2(2w + b - 6) \times 1 = -8

所有引數的偏導數排在一起,叫作梯度。這裡的梯度是 (−16,−8)(-16, -8),兩個旋鈕各自往大里擰,ww 擰得多一些。

一條會反覆用到的規律

把上面兩個偏導數拆開看。兩個式子前面都有 2(2w+b−6)2(2w + b - 6),它是損失對輸出 yy 的導數:輸出每變一點,損失變多少。w=1w = 1、b=0b = 0 時它是 −8,意思是輸出應該變大。後面再乘一個數:ww 乘的是 2,bb 乘的是 1。這兩個數正是它們在 y=w⋅2+b⋅1y = w \cdot 2 + b \cdot 1 裡各自乘著的那個輸入。

所以一個引數的偏導數 = 損失對輸出的導數 × 這個引數乘著的輸入。輸入大,這個旋鈕對輸出的影響就大,分到的“責任”也大;輸入是 0,擰它什麼也改變不了,偏導數就是 0。

這其實是複合函式求導的一個特例,叫鏈式法則:損失透過 yy 依賴 ww,那麼“ww 變一點,損失變多少”就等於“ww 變一點,yy 變多少”乘上“yy 變一點,損失變多少”。中間隔了好幾層也是一樣,把每一層的變化倍數依次乘起來。像一串齒輪,第一個轉一圈,最後一個轉幾圈,就等於沿途各級傳動比相乘。

有了這幾樣工具,就可以開啟那個 10 個引數的 Transformer 了。

二、一個能手算的 Transformer

任務:說出第一個字

先說清楚 Transformer 在做什麼。它是今天大語言模型的基本結構,乾的事情是“看前面的字,猜下一個字”。我們給它一個小到不能再小的任務:字只有 A 和 B 兩個,模型每次讀兩個字,讀到第二個字時,說出第一個字是什麼。一共只有四種輸入:

  • AA → A,AB → A,BA → B,BB → B。

為什麼挑這個任務?因為模型站在第二個位置上做預測,手裡直接拿著的是第二個字,要答對就必須回頭看第一個字。“該看哪裡”正是 Transformer 裡注意力負責的事;訓練好的大模型裡,也確實有專門負責“看前一個字”的注意力1。

一個完整的 Transformer 還有很多別的部件2,我們只留下注意力和最後把結果變成答案的輸出層,其餘全部去掉。

字怎樣變成數

電腦只能處理數,所以每個字先變成三個數。A 記作 (1,0,0)(1, 0, 0),B 記作 (0,1,0)(0, 1, 0):第一個數表示“是不是 A”,第二個數表示“是不是 B”。第三個數是一個位置標記,只有正在做預測的第二個位置上是 1,相當於告訴模型“這是我自己”。

所以輸入 BA 變成兩組數:第一個位置 x1=(0,1,0)x_1 = (0, 1, 0),第二個位置 x2=(1,0,1)x_2 = (1, 0, 1)。這一步是固定的,不參與訓練。

注意力:先打分,再分配比例

注意力要決定兩個位置各看幾成。它分三步。

第一步,提問和亮牌。 第二個位置提出一個“問題”,叫查詢,記作 qq;每個位置各亮出一張“牌”,叫鍵,記作 k1k_1、k2k_2。它們都是用引數和輸入算出來的一個數:查詢用三個引數 wq1,wq2,wq3w_{q1}, w_{q2}, w_{q3},鍵用另外三個引數 wk1,wk2,wk3w_{k1}, w_{k2}, w_{k3},演算法都是“對應位置相乘,再加起來”。比如第二個位置的鍵:

k2=wk1×1+wk2×0+wk3×1k_2 = w_{k1} \times 1 + w_{k2} \times 0 + w_{k3} \times 1

第二步,打分。 查詢和每張牌相乘,得到兩個分數 s1=q k1s_1 = q\,k_1,s2=q k2s_2 = q\,k_2。分數越高,越該看那個位置。

第三步,把分數變成比例。 兩個分數要變成兩個加起來等於 1 的比例 a1a_1、a2a_2,表示第一個位置看幾成、第二個位置看幾成。用的辦法叫 softmax:先對每個分數取 ee 的冪,變成正數,再各自除以總和。

a1=es1es1+es2,a2=es2es1+es2a_1 = \frac{e^{s_1}}{e^{s_1} + e^{s_2}}, \qquad a_2 = \frac{e^{s_2}}{e^{s_1} + e^{s_2}}

為什麼用 ee 的冪?因為它永遠是正的,分數高的分到的比例就大,而且它的導數就是它自己,後面求導時很方便。

輸出:看到了什麼,就說什麼

按比例把兩個字混在一起:看到的東西里,A 佔 hAh_A,B 佔 hBh_B。BA 這個例子裡,第一個字是 B、第二個字是 A,所以 hB=a1h_B = a_1,hA=a2h_A = a_2。

輸出層用四個引數 WAA,WAB,WBA,WBBW_{AA}, W_{AB}, W_{BA}, W_{BB} 給 A、B 兩個答案打分:

zA=WAA hA+WAB hB,zB=WBA hA+WBB hBz_A = W_{AA}\,h_A + W_{AB}\,h_B, \qquad z_B = W_{BA}\,h_A + W_{BB}\,h_B

兩個分數再用一次 softmax,變成“答 A”和“答 B”的機率 pAp_A、pBp_B。

要訓練的引數就是 wqw_q 的 3 個、wkw_k 的 3 個、WW 的 4 個,一共 10 個。初值我們挑了好算的:wq1=wq2=wq3=0.5w_{q1} = w_{q2} = w_{q3} = 0.5;wk1=wk2=0w_{k1} = w_{k2} = 0,wk3=0.5w_{k3} = 0.5;WAA=WBB=0.5W_{AA} = W_{BB} = 0.5,另外兩個是 0。真實的訓練從隨機的小數出發,我們手挑初值,是為了讓數字整齊,並且讓模型一開始是錯的。

三、前向:從輸入算到損失

一個樣本走一遍

從輸入一路算到答案,叫前向計算。拿 BA 來算,正確答案是 B。

查詢:q=0.5×1+0.5×0+0.5×1=1q = 0.5 \times 1 + 0.5 \times 0 + 0.5 \times 1 = 1。鍵:第一個位置是 B,k1=wk2=0k_1 = w_{k2} = 0;第二個位置是 A 加位置標記,k2=wk1+wk3=0.5k_2 = w_{k1} + w_{k3} = 0.5。分數 s1=0s_1 = 0,s2=0.5s_2 = 0.5。

softmax:e0=1e^0 = 1,e0.5=1.649e^{0.5} = 1.649,加起來 2.649,所以 a1=1/2.649=0.378a_1 = 1 / 2.649 = 0.378,a2=0.622a_2 = 0.622。模型把六成多的注意力放在了第二個字,也就是它自己身上,看錯了地方。原因在 wk3w_{k3}:它是 0.5,給帶著“我自己”標記的那個位置加了分。

看到的東西:hA=a2=0.622h_A = a_2 = 0.622,hB=a1=0.378h_B = a_1 = 0.378,六成是 A。輸出分數 zA=0.5×0.622=0.311z_A = 0.5 \times 0.622 = 0.311,zB=0.5×0.378=0.189z_B = 0.5 \times 0.378 = 0.189。再用 softmax:pA=0.531p_A = 0.531,pB=0.469p_B = 0.469。模型更傾向於說 A,答錯了(圖 2)。

前向:樣本 BA 從輸入一路算到損失 十個引數取初值,樣本 BA 的第二個位置先算查詢和鍵,得到注意力權重 0.378 和 0.622,多半看了自己;取出的內容偏向 A,輸出 B 的機率只有 0.469,損失 0.756。 看哪裡:查詢、鍵和注意力 說什麼:取值、輸出和損失 輸入 固定,不訓練 x₁ = B,位置 1 (0, 1, 0) x₂ = A,當前位置 (1, 0, 1) 目標 B 查詢與鍵 w_q₁,₂,₃ 0.5, 0.5, 0.5 w_k₁,₂,₃ 0, 0, 0.5 q(由 w_q 和 x₂ 算) 1 k₁ = w_k₂ 0 k₂ = w_k₁ + w_k₃ 0.5 注意力比例 softmax s₁ = q·k₁ 0 s₂ = q·k₂ 0.5 a₁ 看 x₁ 0.378 a₂ 看 x₂ 0.622 加權取值 h = a₁·B + a₂·A h_A 0.622 h_B 0.378 輸出 softmax W_AA, W_AB 0.5, 0 W_BA, W_BB 0, 0.5 z_A 0.311 z_B 0.189 p_A 0.531 p_B 0.469 損失 L = −ln p_B 0.756 強調色是要訓練的 10 個引數, 其餘數都由它們和輸入算出來 損失越小越好:p_B = 1 時 L = 0
圖 2 · 前向計算:初始引數下,模型把 62% 的注意力放在了自己身上,於是更像在說 A,正確答案 B 只拿到 0.469 的機率

損失:為什麼用 −ln p

熱身裡的損失是“差值的平方”。這裡的答案是一個字,沒有“差多少”可言,用什麼當損失?

最直覺的是數一數答對了幾道。可這個數沒法用來訓練:把某個引數從 0.5 改成 0.51,pBp_B 從 0.469 變成 0.470,答案還是 A,答對的題數一道沒變,導數是 0。分數對小的改動毫無反應,就給不出“該往哪邊擰”的資訊。

所以實際用的是交叉熵損失:

L=−ln⁡p正確答案L = -\ln p_{\text{正確答案}}

ln⁡\ln 是以 ee 為底的對數。BA 的損失是 −ln⁡0.469=0.756-\ln 0.469 = 0.756。它有幾個好記的點:正確答案的機率是 1 時,L=0L = 0;是 0.5,也就是瞎猜時,L=ln⁡2=0.693L = \ln 2 = 0.693;機率越接近 0,LL 越大,沒有上限。pBp_B 每多一點,損失就少一點,哪怕答案還沒翻過來。

另外三個樣本也這樣算。AA 和 BB 兩個字相同,不管注意力放在哪裡,看到的都是同一個字,正確答案的機率是 0.622,損失 0.474;AB 和 BA 情況對稱,損失也是 0.756。四個數取平均:(0.474+0.756+0.756+0.474)/4=0.615(0.474 + 0.756 + 0.756 + 0.474) / 4 = 0.615,這就是開頭打出來的第一個數。

現在的問題和熱身一樣:10 個旋鈕,各該往哪邊擰、擰多少,才能讓 0.615 變小?

四、梯度:每個引數往哪邊調

第一次嘗試:挨個動一下

不會求導也有辦法:一個一個試。把 WBBW_{BB} 從 0.5 調到 0.51,其餘不動,重新算一遍 BA 的損失,0.7563 變成了 0.7542,少了 0.0020。改動 0.01,損失變了 −0.0020,兩者之比是 −0.200。這個比值就是 ∂L/∂WBB\partial L / \partial W_{BB} 的近似值:負的,說明 WBBW_{BB} 該調大。

再試 wk3w_{k3}:從 0.5 調到 0.51,損失多了約 0.00125,比值 +0.125,說明它該調小,和前面“它讓模型看錯了地方”的判斷一致。把 wk3w_{k3} 在一段範圍裡來回掃,畫出損失的樣子(圖 3),跟熱身的拋物線是一回事:損失是一條光滑的曲線,偏導數就是當前這一點的斜率。

只動一個引數時損失的形狀 固定其餘九個引數,把 w_k 的第 3 個數從 −3 掃到 3,樣本 BA 的損失從約 0.474 平滑地升到約 0.974;在當前值 0.5 處,切線斜率是 0.125。 樣本 BA 的損失 · 只改 w_k 的第 3 個數,其餘 9 個引數不動 0 0.4 0.8 1.2 −3 −2 −1 0 1 2 3 w_k 第 3 個數(“當前位置”這一維在鍵裡的權重) 現在:w_k₃ = 0.5,L = 0.756 切線斜率 ∂L/∂w_k₃ = 0.125 斜率為正,往左(調小)是下坡 調到很負:只看 x₁,損失也只降到 0.474 調到很正:只看自己,損失升到 0.974
圖 3 · 梯度就是腳下的坡度:在 0.5 這一點,w_k₃ 每調大 0.01,損失大約多 0.00125,所以該往小裡調

圖 3 還說明了一件事:就算把 wk3w_{k3} 調到很負、注意力全放在第一個字上,BA 的損失也只降到 0.474,因為輸出層的 0.5 太小,答得不夠果斷。要把損失降下去,“看哪裡”和“說什麼”兩頭都得改,10 個引數要一起動。

不足:引數一多就試不動

挨個試,每個引數都要多算一兩次前向。10 個引數還算得過來;GPT-3 有 1750 億個引數,挨個試一遍,就要算 3500 億次前向,而這隻夠走一步。

有沒有辦法算一趟,就得到所有引數的偏導數?

五、反向傳播:從損失往回算

思路:沿途的倍數相乘

熱身裡的鏈式法則說,隔了好幾層,就把每層的變化倍數乘起來。wk3w_{k3} 影響損失的路線是:wk3w_{k3} 改變鍵 k2k_2,k2k_2 改變分數 s2s_2,分數改變比例 aa,比例改變看到的 hh,hh 改變輸出分數 zz,最後 zz 改變損失。

關鍵在於,靠近損失的那幾段路是很多引數共用的。10 個引數都要經過“zz 怎樣影響 LL”這一段;6 個注意力引數還要共同經過 hh、aa、ss。所以從損失出發往回走,每走一層,就把“損失對這一層的導數”記下來,下一層直接拿來乘。一趟走完,所有引數的偏導數就都有了。這就是反向傳播3,它的計算量和一次前向差不多,大約是兩倍,跟引數有多少個無關。

下面沿著圖 2 的箭頭倒著走一遍。每一步只用到熱身裡那兩件事:求導,以及倍數相乘。

逐層往回

第一步:輸出分數。 只有兩個答案時,pB=ezBezA+ezBp_B = \dfrac{e^{z_B}}{e^{z_A} + e^{z_B}}。把損失 L=−ln⁡pBL = -\ln p_B 寫開,再分別對 zAz_A、zBz_B 求導,能得到一個很乾淨的結果:

∂L∂zA=pA=0.531,∂L∂zB=pB−1=−0.531\frac{\partial L}{\partial z_A} = p_A = 0.531, \qquad \frac{\partial L}{\partial z_B} = p_B - 1 = -0.531

(推導:L=−zB+ln⁡(ezA+ezB)L = -z_B + \ln(e^{z_A} + e^{z_B}),對 zAz_A 求導得 ezAezA+ezB=pA\dfrac{e^{z_A}}{e^{z_A}+e^{z_B}} = p_A,對 zBz_B 求導得 −1+pB-1 + p_B。)讀法很直接:A 的分數應該降,B 的分數應該升,力度就是模型離正確答案差多遠。

第二步:輸出層的四個引數。 zA=WAA hA+WAB hBz_A = W_{AA}\,h_A + W_{AB}\,h_B,正是熱身裡那種“引數乘輸入”的形狀。用那條規律,偏導數等於“傳回來的導數 × 這個引數乘著的輸入”:

  • WAAW_{AA}:0.531×0.622=0.3300.531 \times 0.622 = 0.330;WABW_{AB}:0.531×0.378=0.2000.531 \times 0.378 = 0.200;
  • WBAW_{BA}:−0.531×0.622=−0.330-0.531 \times 0.622 = -0.330;WBBW_{BB}:−0.531×0.378=−0.200-0.531 \times 0.378 = -0.200。

WBBW_{BB} 的 −0.200,正好就是前面挨個試出來的那個數。

第三步:看到的東西和注意力比例。 hAh_A 同時出現在 zAz_A 和 zBz_B 裡,兩條路的影響要加起來:∂L/∂hA=0.531×WAA+(−0.531)×WBA=0.531×0.5+0=0.265\partial L / \partial h_A = 0.531 \times W_{AA} + (-0.531) \times W_{BA} = 0.531 \times 0.5 + 0 = 0.265;同理 ∂L/∂hB=−0.265\partial L / \partial h_B = -0.265。看到的 A 多了不好,B 多了好。在 BA 裡 hB=a1h_B = a_1、hA=a2h_A = a_2,所以 ∂L/∂a1=−0.265\partial L / \partial a_1 = -0.265,∂L/∂a2=0.265\partial L / \partial a_2 = 0.265:多看第一個字會讓損失變小。

第四步:穿過 softmax。 兩個比例加起來恆等於 1,一個漲另一個就跌,不能分開算。只有兩個位置時,a1=11+es2−s1a_1 = \dfrac{1}{1 + e^{s_2 - s_1}},求導可以得到:s1s_1 每增加一點,a1a_1 增加 a1a2a_1 a_2 倍,a2a_2 減少同樣多。所以

∂L∂s1=a1a2×(∂L∂a1−∂L∂a2)=0.235×(−0.265−0.265)=−0.125\frac{\partial L}{\partial s_1} = a_1 a_2 \times \Big(\frac{\partial L}{\partial a_1} - \frac{\partial L}{\partial a_2}\Big) = 0.235 \times (-0.265 - 0.265) = -0.125

∂L/∂s2\partial L / \partial s_2 正好相反,是 +0.125。a1a2a_1 a_2 這個倍數值得記住:比例是 0.5 和 0.5 時它最大,是 0.25;如果注意力幾乎全壓在一邊,比如 0.999 和 0.001,它就接近 0,梯度傳到這裡就過不去了。第九節會遇到這種情況。

第五步:查詢和鍵。 s1=q k1s_1 = q\,k_1,對 qq 求導是 k1k_1,對 k1k_1 求導是 qq。所以 ∂L/∂q=−0.125×k1+0.125×k2=−0.125×0+0.125×0.5=0.062\partial L / \partial q = -0.125 \times k_1 + 0.125 \times k_2 = -0.125 \times 0 + 0.125 \times 0.5 = 0.062;∂L/∂k1=−0.125×q=−0.125\partial L / \partial k_1 = -0.125 \times q = -0.125,∂L/∂k2=0.125\partial L / \partial k_2 = 0.125。

第六步:落到 6 個注意力引數上。 又是“傳回來的導數 × 輸入”。q=wq1×1+wq2×0+wq3×1q = w_{q1} \times 1 + w_{q2} \times 0 + w_{q3} \times 1,所以 wq1w_{q1} 和 wq3w_{q3} 的偏導數都是 0.062,wq2w_{q2} 乘著的輸入是 0,偏導數是 0。k1=wk2k_1 = w_{k2},k2=wk1+wk3k_2 = w_{k1} + w_{k3},所以 wk2w_{k2} 的偏導數是 −0.125,wk1w_{k1} 和 wk3w_{k3} 都是 0.125。wk3w_{k3} 的 0.125,正是前面試出來的那個坡度。

反向:從損失往回,逐層算出每個數的梯度 從損失出發往回走:先得到損失對兩個輸出分數的梯度 0.531 和 −0.531,再到輸出矩陣、取值、注意力權重、打分,最後得到十個引數各自的梯度。 然後回到注意力:打分、查詢和鍵 先從損失出發:輸出和取值 輸入 字變成數,這步固定 — 查詢與鍵 ∂L/∂q 0.062 ∂L/∂k₁ −0.125 ∂L/∂k₂ 0.125 ∂L/∂w_q 0.062, 0, 0.062 ∂L/∂w_k 0.125, −0.125, 0.125 注意力比例 ∂L/∂s₁ −0.125 ∂L/∂s₂ 0.125 加權取值 ∂L/∂a₁(= ∂L/∂h_B) −0.265 ∂L/∂a₂(= ∂L/∂h_A) 0.265 輸出 ∂L/∂W_AA,AB 0.330, 0.200 ∂L/∂W_BA,BB −0.330, −0.200 ∂L/∂h_A 0.265 ∂L/∂h_B −0.265 損失 ∂L/∂z_A = p_A − 0 0.531 ∂L/∂z_B = p_B − 1 −0.531 梯度到這裡就停下: 這一步沒有引數要訓練 正數:這個數調大,損失變大 負數:調大,損失變小
圖 4 · 反向傳播:箭頭和圖 2 相反,每一格的梯度都由它下游那一格的梯度乘上本地的導數得到;強調色是十個引數的梯度

一趟走下來,10 個偏導數全部到手(圖 4),每一步都只是求導和乘法。

對賬

手算難免出錯,我們用兩種辦法核對4。一是前面那種“挨個動一下”,10 個數和手算的結果在四位小數上全部一致。二是交給 PyTorch,一個常用的深度學習工具,它能自動做反向傳播。下面這段程式碼可以跳過,只看輸出:

Python
import torch
x1 = 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 @ x2
k = torch.stack([wk @ x1, wk @ x2])
a = torch.softmax(q * k, dim=0)
h = a[0] * x1[:2] + a[1] * x2[:2]
z = Wo @ h
loss = torch.nn.functional.cross_entropy(z[None], torch.tensor([1]))
loss.backward()
print(loss.item(), wq.grad, wk.grad, Wo.grad, sep="\n")
0.756250262260437
tensor([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)。

只用樣本 BA 走一步 · 新值 = 原值 − 1 × 梯度
引數原值梯度新值
w_q₁(A)0.50.0620.438
w_q₂(B)0.500.5
w_q₃(當前位置)0.50.0620.438
w_k₁(A)00.125−0.125
w_k₂(B)0−0.1250.125
w_k₃(當前位置)0.50.1250.375
W_AA0.50.3300.170
W_AB00.200−0.200
W_BA0−0.3300.330
W_BB0.5−0.2000.700

梯度保留三位小數,新值按未舍入的梯度算。

表 2 · 一步更新:十個引數裡有九個動了,w_q₂ 的梯度是 0,原地不動

用新引數把 BA 重新算一遍:注意力 a1a_1 從 0.378 升到 0.473,pBp_B 從 0.469 升到 0.625,損失從 0.756 降到 0.470。模型對 BA 的答案翻了過來,從說 A 變成了說 B。

現象:BA 變好了,別的樣本變差了

但再看看另外三個樣本(表 3)。

按 BA 走了一步之後,四個樣本的損失
樣本走之前走之後
AA → A0.4740.777
AB → A0.7561.061
BA → B0.7560.470
BB → B0.4740.341

BA 自己:a₁ 從 0.378 升到 0.472,p_B 從 0.469 升到 0.625。

表 3 · 只照顧一個樣本:BA 的損失降了,AA 和 AB 反而變差,模型學到的主要是“多說 B”

AA 的損失從 0.474 漲到 0.777,答案也從對變成了錯。原因要回到表 2:變化最大的不是注意力的引數,而是輸出層。對 BA 這一個樣本來說,最快的下坡路是“不管看到什麼,都多說 B”:B 那一行的兩個引數調大,A 那一行調小。這條路比把注意力扭過來陡得多(輸出層的偏導數是 0.330、0.200,wk3w_{k3} 只有 0.125),可它對 AA、AB 是壞事。

一個樣本算出來的坡度,只是這一個樣本的坡度。怎樣讓一步對所有樣本都有好處?

七、一批樣本:把梯度平均

四個樣本各說各的

訓練真正要降的是四個樣本的平均損失。平均數的導數就是導數的平均,所以把四個樣本的偏導數各自算出來,再取平均就行。把它們並排放在一起(表 4),能看出各個樣本在“想”什麼。

初始引數下,四個樣本各自的梯度和它們的平均
引數AAABBABB平均
w_q₁(A)000.06200.016
w_q₂(B)00.062000.016
w_q₃(當前位置)00.0620.06200.031
w_k₁(A)0−0.1250.12500
w_k₂(B)00.125−0.12500
w_k₃(當前位置)00.1250.12500.062
W_AA−0.378−0.2000.3300−0.062
W_AB0−0.3300.2000.3780.062
W_BA0.3780.200−0.33000.062
W_BB00.330−0.200−0.378−0.062

AA 和 BB 兩個字一樣,看哪個位置取到的都是同一個字,所以對 w_q、w_k 的梯度全是 0。

表 4 · 四個樣本各說各的:AB 和 BA 對 w_k₁、w_k₂ 的意見正好相反,平均後抵消;只有 w_k₃ 上大家意見一致

AA 和 BB 對 6 個注意力引數的偏導數全是 0:兩個字一樣,看哪裡都一樣,它們對注意力沒有意見,只希望輸出層更果斷地“看到什麼就說什麼”。

AB 和 BA 在 wk1w_{k1}、wk2w_{k2} 上意見正好相反。BA 希望 A 的牌小一點、B 的牌大一點(這樣會多看第一個字 B),AB 希望的正好反過來。平均後兩者抵消成 0,這是好事:“A 的牌比 B 小”並不是這個任務的規律,只照顧一個樣本才會學到它。

它們在 wk3w_{k3} 上意見一致,都是 +0.125,平均後是 0.062。四個樣本唯一的共識是:把“我自己”這張牌壓低,讓模型少看自己。這正是這個任務真正的規律。

平均之後走一步

用平均梯度走一步(學習率還是 1):wk3w_{k3} 從 0.5 降到 0.438,WAAW_{AA}、WBBW_{BB} 從 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 這時看的還主要是自己(a1a_1 只有 0.397),照抄得越果斷,錯得越果斷。平均梯度保證的是平均損失下降,不保證每個樣本都變好。

真實訓練的樣本有成千上萬,不可能每一步都全部算一遍,於是每一步隨機抽一小批來算平均梯度,這叫隨機梯度下降。一小批的平均只是全體平均的估計,有點偏差,但方向大體是對的,代價卻小得多。

八、多步:從平臺到收斂

現象:難的樣本先停在原地,然後突然下降

一直這樣走下去,前 40 步的情況畫在圖 5 裡。

四十步訓練:損失和注意力 學習率 1、四個樣本一起訓練。前 6 步 AA、BB 的損失先降,AB、BA 幾乎不動;注意力 a₁ 越過 0.5 以後,AB、BA 的損失迅速下降,40 步時降到 0.032。 損失 · 學習率 1,四個樣本一起算梯度 樣本 BA 的注意力 a₁:放在第一個字上的比例 0 0.4 0.8 0 0.5 1 0 10 20 30 40 步 AB、BA AA、BB 0.032 0.378 0.973 第 6 步,a₁ 越過一半;此時 w_k₃ 已從 0.5 降到 −0.028
圖 5 · 前幾步只學會了“照抄看到的字”,等注意力轉到第一個字上,難的兩個樣本才開始降

前 6 步,AA、BB 的損失從 0.474 降到 0.260,AB、BA 卻幾乎原地不動,0.756、0.759、0.755……到第 6 步才到 0.687。這段時間裡並非什麼都沒發生:wk3w_{k3} 每一步都在往下走,0.5、0.438、0.362、0.275……第 6 步降到 −0.028,變成負數;注意力 a1a_1 跟著從 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 步以後,wk3=−1.94w_{k3} = -1.94,wq1w_{q1}、wq2w_{q2} 約 0.99,wq3w_{q3} 約 1.48,WAAW_{AA}、WBBW_{BB} 是 2.91,另外兩個是 −2.41。

把它們代回模型就能讀出它學會的規則。查詢 q=0.99+1.48=2.47q = 0.99 + 1.48 = 2.47,是個正數;第一個字的牌是 0,第二個字因為帶著“我自己”標記,牌是 −1.94。分數一個是 0、一個是 2.47×(−1.94)=−4.82.47 \times (-1.94) = -4.8,softmax 之後 a1=0.992a_1 = 0.992。也就是說,模型學會了“別看自己,看前一個字”,再用輸出層把看到的字照抄出來。這條規則沒有人寫過,是四個樣本的梯度一步步推出來的。

損失永遠不會恰好是 0:要 pp 正好等於 1 才行,而 softmax 給不出正好的 1,引數只能越來越大地逼近它。真實訓練也不會等到“完全收斂”,而是在預算用完、或者在沒見過的資料上的成績不再變好時停下。

走到的這個地方也不是唯一的。我們換掉手挑的初值,讓 10 個引數從隨機數出發,跑了 100 次,每次都在 20 到 37 步之內把平均損失降到 0.05 以下,一次也沒有失敗;可最後的引數各不相同,光是 wk3w_{k3} 就散佈在 −1.82 到 1.77 之間。wk3w_{k3} 是正數的那些解,查詢恰好是負數,負負得正,同樣做到了“別看自己”。梯度下降找到的不是“那個”最優解,而是一大片同樣好的解裡離起點比較近的一個4。

還有一個數是我們隨手定的:學習率為什麼取 1?

九、學習率:步子邁多大

現象:大了更快,再大就卡死

同一個起點,換四種學習率各跑 60 步(圖 6)。

學習率對訓練的影響 學習率 0.1 時損失下降很慢,60 步後還有 0.469;學習率 1 約 20 步降到 0.08;學習率 10 三步就降到 0.031;學習率 30 第三步跳到 3.792,之後停在 3.7 左右不再下降。 四個樣本的平均損失 · 同一個起點,四種學習率 0 0.5 1 0 10 20 30 40 50 60 步 0.1:60 步時還有 0.469 1:20 步到 0.076 10 30:第 3 步跳到 3.792,之後一直卡在 3.7 上下(超出縱軸)
圖 6 · 步子太小走得慢,步子太大會一步跨過山谷,落到坡度為 0 的平地上再也走不回來

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 步,wk3w_{k3} 一下變成 7.56,三個查詢引數變成 15.2、15.2、30.0。這時 BA 第二個位置的分數是 341,第一個位置是 0,softmax 給出的比例是 (0,1)(0, 1):模型只看自己。

還記得反向傳播第四步裡的那個倍數 a1a2a_1 a_2 嗎?現在它是 0。損失再怎麼變,傳到分數這裡都乘上了 0,6 個注意力引數再也收不到任何訊號,注意力永遠轉不回來。剩下的輸出層只能看到第二個字,而第二個字和答案無關,它最好的做法是兩個字各給一半機率;可是學習率太大,它每一步都衝過頭,在兩邊來回翻,損失就停在 3.7 上下。

這也是大模型訓練裡很多做法的來由。GPT-3 的學習率只有 0.00006,開始時還要從 0 慢慢升上去,後面再逐漸降低;偏導數整體太大時,還會按比例縮小再用5。這些手段都是為了不讓某一步邁得太遠,掉進坡度為 0、再也走不出來的地方。

十、放大到真實的 Transformer

我們的模型和 GPT-3 走的是同一套流程:前向算損失,反向算梯度,減一步,重複。差別在下面這張表裡。

本文的模型與 GPT-3
專案本文GPT-3
引數101750 億
結構一層注意力,查詢和鍵各是 1 個數96 層,每層 96 組注意力,查詢和鍵各是 128 個數
其他部件沒有每層還有一個小網路和幾處幫助訓練穩定的結構;字怎樣變成數也參與訓練
一步用的題目4 道約 320 萬道
訓練資料4 道題反覆用約 3000 億個詞元
求梯度手算,再用工具核對工具自動做反向傳播
更新規則引數減去學習率乘偏導數同樣的思路,但每個引數有自己的步長
學習率10.00006

GPT-3 的數字取自論文表 2.1 和附錄 B。詞元是模型處理文字的單位,一個詞元大致是一個英文單詞或一兩個漢字。

表 5 · 引數差了十個數量級,每一步做的事沒有變

幾處差別值得多說一句。

每個位置都是一道題。 我們的模型只在第二個位置答題;語言模型在每個位置都猜下一個詞元,一段 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。

把平均損失降到 0.05 以下要多少次計算 · 每格是不同隨機種子的結果
引數個數梯度:步數梯度:摺合前向次數黑箱:評估次數
3632 / 29 / 3796 / 87 / 11155 / 37 / 28
8048 / 47 / 43144 / 141 / 129180 / 97 / 96
19269 / 69 / 65207 / 207 / 195337 / 356 / 393
51288 / 87 / 86264 / 261 / 258648 / 685 / 844
1,536137 / 105 / 195411 / 315 / 5853,695 / 1,482 / 失敗
5,120368 / 2431,104 / 729失敗 / 失敗

梯度一步按 3 次前向折算。黑箱上限 30 萬次評估,“失敗”是用完 30 萬次仍未達標。

表 6 · 引數越多,只看結果的搜尋越吃力;梯度一步拿到所有引數的方向,步數漲得很慢

只有 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:

Python
import torch
emb = {"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 之後,坡已經很緩,模型基本學會了“看前一個字”。

小結

  1. 訓練在做什麼? 把一個叫損失的數擰小。損失要對引數的每一點變化都有反應,才算得出坡度:“答對幾道”不行,交叉熵 −ln⁡p正確答案-\ln p_{\text{正確答案}} 可以。
  2. 梯度下降是什麼? 算出損失對每個引數的偏導數,也就是坡度,每個引數減去學習率乘它的偏導數,重複。一個旋鈕時,它就是沿著拋物線一步步走到谷底。
  3. 反向傳播做了什麼? 從損失往回,把沿途每一層的變化倍數依次相乘,一趟算出所有引數的偏導數,不用挨個去試。最常用的一條:引數的偏導數等於傳回來的導數乘上它乘著的輸入,輸入是 0,偏導數就是 0。
  4. 為什麼要一批樣本一起算? 只按一個樣本走,會學到只對它有用的捷徑;按一批樣本的平均走,互相矛盾的意見抵消,剩下的是共同的規律。
  5. 為什麼要走很多步,曲線為什麼先平後陡? 坡度只在腳下可靠,所以每次只走一小步。注意力沒轉過來之前,難的樣本幾乎不動;越過一半以後,“看哪裡”和“說什麼”互相放大,損失迅速下降;之後坡越來越緩,這就是收斂。
  6. 學習率為什麼要小心? 太小走得慢,太大會跨過谷底,甚至跳進坡度為 0 的地方再也出不來。
  7. 為什麼這裡找解比現實中容易? 找到的不是唯一的最優解,而是一大片好解裡的一個;更關鍵的是,損失是寫出來的公式,一趟反向傳播就拿到所有引數的坡度,試錯又便宜。只看結果的隨機搜尋,代價隨引數個數上漲,到大模型的規模就完全走不動。現實問題湊齊這些條件也能用梯度解;Transformer 裡湊不齊的部分,比如層數和學習率,也只能靠試。

參考資料

參考資料

  1. In-context Learning and Induction HeadsCatherine Olsson 等 · Transformer Circuits Thread · 2022transformer-circuits.pub ↗訓練好的 Transformer 裡有專門“看前一個詞元”的注意力頭(previous token head),它和後面的歸納頭配合完成複製。https://transformer-circuits.pub/2022/in-context-learning-and-induction-heads/index.html ↩

  2. Attention Is All You NeedAshish Vaswani 等 · NeurIPS 2017arxiv.org ↗Transformer 的原始論文。注意力打分除以 √d_k 的做法見第 3.2.1 節。https://arxiv.org/abs/1706.03762 ↩

  3. Learning representations by back-propagating errorsDavid E. Rumelhart, Geoffrey E. Hinton, Ronald J. Williams · Nature 323 · 1986doi.org ↗https://doi.org/10.1038/323533a0 ↩

  4. 本文的實驗指令碼與日誌專案共享目錄 gradient-descent-research/:experiment/tiny.py 是模型和手寫的反向傳播,walk.py 列印 BA 一步的全部中間值,batch.py 是四個樣本的梯度和多步軌跡,torch_check.py、train_torch.py 用 PyTorch 自動求導對賬,build_figs.py 生成文中的圖和表。 ↩ ↩2 ↩3

  5. Language Models are Few-Shot LearnersTom B. Brown 等 · NeurIPS 2020arxiv.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

  6. Adam: A Method for Stochastic OptimizationDiederik P. Kingma, Jimmy Ba · ICLR 2015arxiv.org ↗https://arxiv.org/abs/1412.6980 ↩

延伸閱讀