6/30บทที่ 6 จาก 30

ทำให้ฝึกได้ และทำให้ใช้ได้กับข้อมูลใหม่

แก้ network 6 ชั้นที่ loss ค้างที่ ln 2 ทีละการวัด แล้วไปต่อกับ double descent: 5,000 parameters บน 40 จุด

26 มิถุนายน 2569อัปเดต 11 กันยายน 2569อ่าน 12 นาที

ในหน้านี้

network จาก บทที่ 5 ใช้งานได้ มันมี parameter 9 ตัว เรียนรู้ XOR ได้ และ gradient ของมันตรงกับ PyTorch ถึงระดับทศนิยม 16 ตำแหน่ง

ทำให้มันลึก 6 ชั้น แล้วมันหยุดเรียนรู้ไปเลย ไม่ใช่ช้า — หยุดสนิท นี่คือ network 6 ชั้นบนปัญหา classification แบบสองเกลียว ฝึก 5000 steps:

TEXT

step    1: loss 0.693147
step 5000: loss 0.693147
accuracy: 50.0 %

ตัวเลขนั้นไม่ใช่เรื่องบังเอิญ $\ln 2 = 0.693147$ คือ binary cross-entropy ของ model ที่ให้ความน่าจะเป็น $0.5$ กับทุกอย่าง และ 50 % ก็คือการโยนเหรียญบน dataset ที่สมดุล หลังจาก 5 พัน steps network ไม่ขยับแม้แต่หลักเดียว ไม่มีอะไร crash ไม่มี warning และ gradient ก็ยังถูกต้องเป๊ะ

บทนี้ว่าด้วยช่องว่างระหว่าง network ที่รันได้กับ network ที่ใช้งานได้จริง มันมีสองครึ่งที่ดูเหมือนคนละเรื่อง แต่แท้จริงคืองานเดียวกัน: ทำให้ loss ลดลง และทำให้มันลดลงบนข้อมูลที่ model ไม่เคยเห็นมาก่อน

ทำไม network 6 ชั้นถึงตาย

ลิงก์ไปยังส่วน: ทำไม network 6 ชั้นถึงตาย

เริ่มด้วยการดู แทนที่จะเดา ส่ง batch ของ input ผ่านเข้าไป แล้วพิมพ์ standard deviation ของ activation ในแต่ละ layer จากนั้นพิมพ์ standard deviation ของ weight gradient:

profile.pyPYTHON

def profile(model, x):
    h = x
    for layer in model:
        h = layer(h)
        if isinstance(layer, (nn.Tanh, nn.ReLU)):
            print(f"activation std: {h.std().item():.4f}")
    model(x).sum().backward()
    for p in model.parameters():
        if p.dim() == 2:
            print(f"gradient std: {p.grad.std().item():.2e}")

initialisation 3 แบบ architecture เดียวกัน $\tanh$ 6 ชั้น:

initialisation	activation std, layers 1→6
normal, std $0.01$	0.0145 · 0.0016 · 0.0002 · 0.0000 · 0.0000 · 0.0000
normal, std $1$	0.6573 · 0.9296 · 0.9585 · 0.9634 · 0.9637 · 0.9625
Xavier	0.1579 · 0.1493 · 0.1353 · 0.1333 · 0.1325 · 0.1403

initialisation	gradient std, first layer → last
normal, std $0.01$	3.20e-06 · 4.97e-07 · … · 6.40e-06
normal, std $1$	1.94e+03 · 2.28e+02 · 1.22e+02 · 4.43e+01 · 1.85e+01 · 7.30e+00
Xavier	2.31e+00 · 4.50e-01 · 4.26e-01 · 3.89e-01 · 4.39e-01 · 4.73e-01

แถวแรกคือ network ข้างบน และมันไม่ได้เรียนรู้ช้า — มันไม่มี signal เหลืออยู่แล้ว พอถึง layer สี่ standard deviation ของ activation ก็ underflow เป็นศูนย์เมื่อดูถึงทศนิยม 4 ตำแหน่ง input ทุกตัวให้ output เดียวกัน output เป็นค่าคงที่ และ gradient ของค่าคงที่ก็คือไม่มีอะไรเลย weight ถูก initialised ให้เล็ก “เพื่อความปลอดภัย” และความเล็กนั้นถึงตาย

แถวที่สองคือความล้มเหลวในทางตรงข้าม และควรทำความเข้าใจเพราะมันขัดกับสัญชาตญาณ activation ดูสุขภาพดี — ประมาณ 0.96 — แต่นั่นคือ $\tanh$ ที่ saturated ถูกตรึงอยู่ใกล้ขีดจำกัดพอดี ซึ่งเป็น regime ที่บทที่ 5 วัดไว้ว่าเสีย gradient ไปเกือบหนึ่งหมื่นเท่า แต่ gradient กลับมหาศาล: 1940 ที่ layer แรก ทั้งสองอย่างเป็นจริงพร้อมกันได้ แต่ละ backward step คูณด้วย $W^\top$ และเมื่อมี input 128 ตัวที่ variance หนึ่ง factor นั้นมี gain ประมาณ $\sqrt{128} \approx 11$ ซึ่งกลบการหดตัวจาก $\tanh$ ที่ saturated ไปหมด gradient โตแบบเรขาคณิตระหว่างย้อนกลับ นี่คือ exploding gradient และมันสร้างค่า loss เป็น nan ภายในไม่กี่ steps ในการฝึกจริง

แถวที่สามคือสิ่งที่คุณต้องการ: activation มี scale ค่อนข้างคงที่ข้าม depth และ gradient ก็มี scale ค่อนข้างคงที่ข้าม depth ไม่มีอะไรตาย ไม่มีอะไรระเบิด

สูตร initialisation มาจากไหน ในเลขคณิตหนึ่งย่อหน้า

unit หนึ่งคำนวณ $z = \sum_{i=1}^{n} w_i x_i$ ถ้า $w_i$ เป็นอิสระต่อกันโดยมี variance $\sigma_w^2$ และ $x_i$ เป็นอิสระต่อกันโดยมี variance $\sigma_x^2$ variance ของผลรวมก็คือผลรวมของ variance:

\mathrm{Var}(z) = n\,\sigma_w^2\,\sigma_x^2

เพื่อให้ signal รักษา scale เดิมจาก layer หนึ่งไปอีก layer หนึ่ง คุณต้องการ $\mathrm{Var}(z) = \sigma_x^2$ ซึ่งบังคับให้ $\sigma_w^2 = 1/n$ นั่นคือ derivation ทั้งหมด Glorot และ Bengio¹ เฉลี่ย constraint สำหรับ forward pass ( $n_{\text{in}}$ ) กับ constraint สำหรับ backward pass ( $n_{\text{out}}$ ) ได้เป็น $\sigma_w^2 = 2/(n_{\text{in}} + n_{\text{out}})$ — Xavier initialisation He et al.² สังเกตว่า ReLU ทำให้ input ครึ่งหนึ่งเป็นศูนย์ ทำให้ variance เหลือครึ่งหนึ่ง และชดเชยด้วย $\sigma_w^2 = 2/n_{\text{in}}$ — He initialisation ซึ่งเป็นสิ่งที่คุณใช้กับ ReLU

เมื่อ $n = 128$ , Xavier ให้ $\sigma_w \approx 0.088$ run ที่ล้มเหลวใช้ $0.01$ : ไม่ใช่ปรัชญาที่ต่างกัน แต่ต่างกันเก้าเท่า และเป็นความต่างระหว่าง network ที่เรียนรู้กับ network ที่ไม่เรียนรู้

Normalisation และแบบไหนที่รอด

ลิงก์ไปยังส่วน: Normalisation และแบบไหนที่รอด

การ initialise ให้ดีแก้ scale ณ step ศูนย์ แต่มันไม่ได้ทำให้ scale คงที่ตลอดไป: weight ขยับ และพอถึง step 5 พัน เหตุผลเรื่อง variance ที่ระวังมาอย่างดีก็ไม่ใช้ได้แล้ว

normalisation layer บังคับ scale อย่างต่อเนื่อง เมื่อมีเวกเตอร์ของ activation ให้ลบ mean หารด้วย standard deviation แล้วใช้ scale $\gamma$ และ shift $\beta$ ที่เรียนรู้ได้ เพื่อให้ layer ย้อนคืน normalisation ได้ถ้านั่นกลายเป็นสิ่งที่มันต้องการ:

\hat{h} = \frac{h - \mu}{\sqrt{\sigma^2 + \epsilon}}, \qquad y = \gamma\hat{h} + \beta

คำถามจริงข้อเดียวคือ คุณ average เหนืออะไร Batch normalisation³ หา $\mu$ และ $\sigma$ ข้ามมิติ batch หนึ่ง statistic ต่อ feature Layer normalisation⁴ หา statistic เหล่านั้นข้าม features หนึ่ง statistic ต่อ example

ตัวเลือกนี้ดูเล็กน้อย แต่ตัดสินแทบทุกอย่างที่ตามมา:

BatchNorm ทำให้ output ของแต่ละ example ขึ้นกับ example อื่น ๆ ที่บังเอิญอยู่ใน batch เดียวกัน ตอน training นั่นเป็น regulariser แบบอ่อน ๆ ตอน inference ไม่มี batch ให้ใช้ จึงต้องเก็บ running average ของ statistic ที่สะสมระหว่าง training — ซึ่งหมายความว่า layer มีพฤติกรรมต่างกันในโหมด training และ evaluation และการลืมสลับโหมดคือหนึ่งใน bug ที่พบบ่อยที่สุดในวงการ มันยังเสื่อมลงเมื่อ batch เล็ก และใช้งานลำบากกับ sequence ความยาวไม่เท่ากัน เพราะ “mean เหนือ batch ที่ตำแหน่ง 40” คำนวณจาก sequence เท่าที่บังเอิญยาวถึงตรงนั้น

LayerNorm normalise แต่ละ example ด้วยตัวมันเอง ไม่มีการพึ่งพา batch ไม่มี running statistics พฤติกรรมเหมือนกันใน training และ inference ไม่สนใจ batch size ไม่สนใจ sequence length คุณสมบัติทุกข้อกลายเป็นข้อกำหนด ไม่ใช่แค่เรื่องดีที่มี เมื่อคุณ generate ทีละ token ให้ผู้ใช้คนเดียว ซึ่งคือจุดที่ บทที่ 13 จะไปถึง

นี่คือเหตุผลที่ LayerNorm เป็นสิ่งที่คุณจะพบอีกครั้งใน บทที่ 9 แบบ ไม่เปลี่ยนแปลง: transformer block ใช้มัน และใช้มันด้วยเหตุผลในคอลัมน์ขวา ไม่ใช่เพราะมันทำงานดีกว่าในเชิงนามธรรม

แก้ทีละอย่าง ซึ่งคือ skill จริง

ลิงก์ไปยังส่วน: แก้ทีละอย่าง ซึ่งคือ skill จริง

มี candidate fix สี่อย่างสำหรับ network ที่ตาย: Xavier initialisation, LayerNorm, residual connections และ Adam แทน SGD ความเย้ายวนคือใส่ทั้งสี่อย่างแล้วเดินหน้าต่อ ทำแบบนั้นแล้วคุณจะไม่มีวันรู้ว่าอะไรสำคัญ และครั้งหน้าที่เกิดขึ้น คุณจะไม่มี method — มีแค่พิธีกรรม

ดังนั้นให้ใส่ทีละอย่าง seed เดิม data เดิม architecture เดิม 800 steps:

what was added	final loss	accuracy
nothing	0.6931	50.0 %
Xavier initialisation	0.5692	60.4 %
LayerNorm	0.6230	61.5 %
residual connections	0.6651	56.6 %
Adam	0.6787	58.7 %
all four	0.0000	100.0 %

อ่านตารางนั้นแบบที่คุณจะอ่านตอนตีสอง แล้วข้อสรุปคือ: ไม่มีอะไรได้ผลเดี่ยว ๆ ทุกอย่างได้ผลเมื่อรวมกัน ดังนั้น deep learning คือ alchemy ข้อสรุปนั้นผิด และการค้นให้เจอว่าทำไมคือสิ่งที่มีประโยชน์ที่สุดในบทนี้

ให้ budget แต่ละ run มากขึ้นหกเท่า — 5000 steps แทน 800 — แล้วภาพเปลี่ยนไปทั้งหมด:

what was added	final loss @ 5000	accuracy
nothing	0.6931	50.0 %
Xavier initialisation	0.0007	100.0 %
LayerNorm	0.0002	100.0 %
residual connections	0.6653	56.7 %
Adam	0.6908	53.4 %
Xavier + Adam	0.0000	100.0 %
Xavier + LayerNorm	0.0001	100.0 %

ตอนนี้ภาพคมชัด และมันคือ diagnosis ไม่ใช่พิธีกรรม

Initialisation อย่างเดียวแก้ได้ Normalisation อย่างเดียวก็แก้ได้ ทั้งคู่จัดการโรคจริง — forward signal ยุบลงเป็นศูนย์ — และอย่างใดอย่างหนึ่งก็เพียงพอ ที่ 800 steps มันแค่ดูเหมือนได้คะแนนบางส่วน เพราะมันแก้ปัญหาแล้วแต่ยังอยู่ระหว่างไต่กลับขึ้นมา

Residual connections และ Adam แก้ไม่ได้ ไม่ว่า budget เท่าไร ไม่ใช่เพราะมันแย่ แต่เพราะมันรักษาคนละโรค residual connection ให้ path แก่ gradient เพื่ออ้อม layer ที่ขวางอยู่ นั่นมีค่ามากเมื่อปัญหาคือ gradient และไม่มีค่าเลยเมื่อ forward signal เป็นศูนย์ไปแล้ว เพราะ shortcut ที่อ้อม layer ที่ตายก็ยังพาค่าที่ตายไป Adam rescale step ของแต่ละ parameter ด้วยประวัติ gradient ของมันเอง สิ่งนี้ช่วยเมื่อ gradient มี magnitude ต่างกันมหาศาล แต่ไม่สามารถปลุก network ที่ output ไม่ขึ้นกับ input ให้ฟื้นขึ้นมาได้

และ “nothing” ก็ยังเป็น 0.6931 เป๊ะหลัง 5 พัน steps ไม่ใช่ 0.6929 มันไม่ได้ช้า มันตาย และความแตกต่างนั้นมองเห็นได้แบบที่ก่อนหน้านี้มองไม่เห็น เพราะคุณมีแถวที่บอกว่า fix ใช้งานได้ให้เปรียบเทียบ

ตารางวินิจฉัย loss curve มีรูปทรง และรูปทรงนั้นให้ข้อมูล สิ่งต่อไปนี้คือจุดเริ่มต้นของการค้นหา ไม่ใช่ diagnosis — แต่มันเป็นจุดเริ่มต้นที่ดีกว่าการเปลี่ยนสี่อย่างพร้อมกันมาก

what the loss does	most likely cause	first thing to check
flat สมบูรณ์ที่ $\ln 2$ (หรือ $\ln k$ ) ตั้งแต่ step 1	forward signal ตาย หรือ graph หลุดการเชื่อมต่อ	print activation std ต่อ layer; ยืนยันว่า `loss.backward()` สร้าง `.grad` ที่ไม่เป็นศูนย์
`nan` ภายในไม่กี่ steps	exploding gradients หรือ `log(0)` ใน loss	gradient norm ก่อน step; ใช้ loss ที่เสถียรเชิงตัวเลข (บทที่ 4)
ลดลงแล้วกระโดดเป็นค่ามหาศาล	learning rate สูงเกินไป หรือมี batch แย่หนึ่ง batch	gradient clipping; log loss ต่อ batch แล้วหา outlier
ลดลงแล้ว plateau สูง	underfitting หรือ learning rate เล็กเกินไปแล้ว	เพิ่ม capacity, schedule ให้นานขึ้น, ตรวจ decay
train loss ลง, validation loss ขึ้น	overfitting — ครึ่งหลังของบทนี้	regularisation, early stopping, data มากขึ้น
train loss ลงแต่ช้าและมี noise	batch เล็กเกินไป หรือ learning rate schedule ผิด	batch ใหญ่ขึ้น, warmup
loss ลดลงในอัตราที่เร็วอย่างน่าสงสัย	มี leak: target มองเห็นได้ใน input หรือ evaluate บน training data	audit split ก่อนฉลอง

ทำให้คู่ควรกับ PyTorch

ลิงก์ไปยังส่วน: ทำให้คู่ควรกับ PyTorch

จากนี้ไป course นี้ใช้ PyTorch เรื่องนี้ควรได้มาด้วยความเข้าใจ ไม่ใช่แค่ประกาศ ดังนั้นนี่คือสิ่งที่มันทำ ซึ่งคุณรู้วิธีทำอยู่แล้ว

optimiser คือกฎสำหรับเปลี่ยน gradient ให้เป็นการ update parameter plain gradient descent ใช้ gradient Momentum ใช้ running average ของมัน ซึ่งทำให้ noise เรียบลงและสร้างความเร็วตามทิศทางที่สอดคล้องต่อเนื่อง:

optim_by_hand.pyPYTHON

v = beta * v + p.grad          
p -= lr * v

Adam⁵ เก็บ running average สองชุด — ของ gradient และของ gradient ยกกำลังสอง — แล้วหารตัวหนึ่งด้วย square root ของอีกตัว เพื่อให้แต่ละ parameter ได้ step ที่ scale ตาม magnitude ของ gradient ล่าสุดของตัวเอง:

optim_by_hand.pyPYTHON

m = b1 * m + (1 - b1) * g          # mean of the gradient          
v = b2 * v + (1 - b2) * g * g      # mean of the squared gradient  
m_hat = m / (1 - b1 ** t)          # bias correction: both averages start at zero
v_hat = v / (1 - b2 ** t)
p -= lr * m_hat / (v_hat.sqrt() + eps)

สิบบรรทัด รันทั้งคู่เทียบกับ torch.optim บนปัญหาเดียวกัน 50 steps:

TEXT

SGD+momentum   by hand [2.7781870365142822, -1.0304985046386719]
               torch   [2.7781870365142822, -1.0304983854293823]   max |diff| = 1.19e-07
Adam           by hand [0.4893140196800232, -0.46317872405052185]
               torch   [0.48931416869163513, -0.46317875385284424]   max |diff| = 1.49e-07

เหมือนกันถึง precision ของ float32 torch.optim.Adam คือห้าบรรทัดนั้น บวกกับความใส่ใจ edge case หลายสิบปีและ C++ kernel นี่คือ trade ที่คุณกำลังทำจากนี้ไป: ไม่ใช่แลกความเข้าใจกับเวทมนตร์ แต่แลกบรรทัดที่คุณเขียนไปแล้วกับความเร็ว

AdamW และ bug ที่อยู่ในทุก framework มาหลายปี Adam มักใช้คู่กับ weight decay — แรงดึง parameter ทุกตัวเข้าหาศูนย์ ซึ่งคือ L2 regularisation implementation ที่ดู obvious คือเพิ่ม $\lambda w$ เข้าไปใน gradient แต่ Adam จะหาร gradient ที่รวมแล้วนั้นด้วย $\sqrt{\hat{v}}$ ดังนั้น ปริมาณ decay ที่ parameter ได้รับจึงขึ้นกับประวัติ gradient ของมัน: parameter ที่มี gradient ใหญ่จะถูก decay น้อยกว่า นั่นไม่ใช่สิ่งที่ใครตั้งใจ และทำให้ decay coefficient เดียวกันมีพฤติกรรมต่างจาก coefficient เดียวกันเมื่อใช้กับ SGD

Loshchilov และ Hutter⁶ แยกสองอย่างนี้ออกจากกัน โดยใช้ decay กับ weight โดยตรงหลัง adaptive step นั่นคือ AdamW เป็น default สำหรับการฝึก language model และเหตุผลที่มันมีอยู่คือความไม่ตรงกันระหว่าง idea กับ implementation ที่รอดมาได้หลายปีทั้งที่ทุกคนใช้มัน

ทำไม Adam จึงมีอยู่: curvature

ลิงก์ไปยังส่วน: ทำไม Adam จึงมีอยู่: curvature

คำอธิบายทั่วไปของ Adam คือ “adaptive per-parameter learning rates” ซึ่งเป็นคำบรรยาย ไม่ใช่เหตุผล เหตุผลคือ geometry และมันวัดได้

ลอง loss ที่ curvature ต่างกันตามทิศทาง: ชันในทิศหนึ่ง ตื้นในอีกทิศ SGD มี learning rate global เพียงค่าเดียว จึงต้องเลือกค่าที่เล็กพอให้ stable ในทิศที่ชันที่สุด — แล้วค่านั้นก็เล็กเกินไปมากสำหรับทิศที่ตื้น ซึ่ง progress คลานช้า นี่คือสิ่งที่ทำให้เกิดภาพคลาสสิกของ gradient descent ที่ zig-zag ลงไปในหุบเขาแคบ

curvature ratio สองค่า optimiser สามตัว 300 steps และแต่ละ optimiser ได้ learning rate ที่ดีที่สุดจากการ sweep เพื่อไม่ให้ใครเสียเปรียบ:

curvature ratio	SGD	SGD + momentum	Adam
10 : 1	error 0.000002	error 0.000000	error 0.000000
1000 : 1	error 1.925485	error 0.001432	error 0.000000
diverged at (1000:1)	4 of 8 rates	4 of 8 rates	0 of 6 rates

ที่ ratio สิบ ทุกอย่างใช้ได้และไม่มีอะไรต้องถก ที่หนึ่งพัน plain SGD ไปไม่ถึงคำตอบที่ learning rate ใด ๆ ที่ลอง — ผลลัพธ์ที่ดีที่สุดยัง error 1.93 — และ diverge ทันทีในครึ่งหนึ่งของค่า learning rate Adam ลงเป้าพอดีและไม่ diverge เลย

คอลัมน์สุดท้ายนั่นคือเหตุผลเชิงปฏิบัติที่ Adam เป็น default ไม่ใช่ว่า Adam หา solution ที่ดีกว่า บนปัญหาที่ well-conditioned, SGD ที่ tune ดีมักเสมอหรือชนะมันได้ แต่ Adam ไวต่อ learning rate ที่คุณเลือกน้อยกว่ามาก และ network จริงมี curvature ratio แย่กว่าหนึ่งพันมากใน parameter หลายล้านตัวของมัน

อีกสองชิ้นควรอยู่ตรงนี้ และทั้งคู่คือหนึ่งบรรทัด Gradient clipping rescale เวกเตอร์ gradient เมื่อ norm ของมันเกิน threshold ซึ่งเปลี่ยนแถว “loss กระโดดเป็นค่ามหาศาลทันที” ในตารางวินิจฉัยให้กลายเป็น non-event และ learning rate schedules: warmup สั้น ๆ จากเกือบศูนย์ในไม่กี่ร้อย steps แรก เพราะ variance estimate ของ Adam ยังเป็นขยะจนกว่าจะเห็น gradient บางส่วน และ step เต็มขนาดที่เกิดบนขยะสามารถทำลาย initialisation ได้ จากนั้น cosine decay เข้าหาศูนย์ เพราะการจบ run ด้วย step size เดียวกับตอนเริ่ม หมายถึงการสั่นอยู่รอบ minimum แทนที่จะนิ่งลงในนั้น

ครึ่งหลัง: model ที่ fit สมบูรณ์แบบแต่ทำนายอะไรไม่ได้

ลิงก์ไปยังส่วน: ครึ่งหลัง: model ที่ fit สมบูรณ์แบบแต่ทำนายอะไรไม่ได้

ทุกอย่างจนถึงตอนนี้ว่าด้วยการทำให้ loss ลดลง ตอนนี้คือครึ่งที่ยากกว่า เพราะ loss ที่ลดลงไม่ใช่เป้าหมาย — มันเป็น proxy ของเป้าหมาย และ proxy นี้ล้มเหลวในแบบเฉพาะที่โด่งดัง

จุด 12 จุดจากฟังก์ชันเรียบที่มี noise เล็กน้อย fit polynomial ที่ degree สูงขึ้นเรื่อย ๆ:

degree	train RMSE	test RMSE
1	0.764499	0.6985
3	0.252605	0.3031
5	0.164437	0.1568
9	0.088960	0.2347
11	0.000000	1.2094

Degree 11 ผ่านจุด 12 จุดได้ ทุกจุดแบบเป๊ะ ๆ — train error เป็นศูนย์ถึงทศนิยม 6 ตำแหน่ง — และแย่กว่า degree 5 ถึงแปดเท่าบนข้อมูลที่มันไม่เคยเห็น ขอให้ degree 3 และ degree 11 ทำนายที่ $x = 3.25$ ซึ่งอยู่นอกช่วง training ไปเล็กน้อย:

TEXT

degree  3: predicts   -1.053   (truth -0.012)
degree 11: predicts  +61.224   (truth -0.012)

หกสิบเอ็ด ทั้งที่คำตอบประมาณศูนย์ model ไม่ได้เรียนรู้ฟังก์ชัน มันเรียนรู้จุดทั้ง 12 จุด และระหว่างจุดเหล่านั้นมันทำอะไรก็ตามที่เลขคณิตบังคับ

นี่คือ overfitting และด้านตรงข้ามของมัน — degree 1 ซึ่งไม่สามารถแทน curve ได้เลยและแย่ทุกที่ — คือ underfitting คำอธิบายแบบคลาสสิกแบ่ง expected error ของ model เป็นสามส่วน: bias คือ error จากการที่ model แข็งเกินไปจนแทนความจริงไม่ได้; variance คือ error จากการที่ model ยืดหยุ่นมากจนไล่ตาม noise ใน sample เฉพาะนี้; และ noise ที่ลดไม่ได้ ซึ่งไม่มีอะไรแก้ได้ model เรียบง่ายมี bias ส่วน model ยืดหยุ่นมี variance สูง และคำแนะนำแบบคลาสสิกคือหาจุดพอดีตรงกลาง — degree 5 ในตารางข้างบน

เครื่องมือมาตรฐานทั้งหมดโจมตี term ของ variance:

L2 regularisation (weight decay) เพิ่ม $\lambda \lVert w \rVert^2$ เข้าไปใน loss ดึง weight เข้าหาศูนย์และทำให้ฟังก์ชันเรียบขึ้น ในตารางข้างบน coefficient ที่ใหญ่ที่สุดของ degree 11 คือสิ่งที่สร้างความเสียหาย การลงโทษขนาดช่วยปลดชนวนมัน
L1 เพิ่ม $\lambda \sum |w_i|$ แทน ความต่างไม่ใช่แค่ cosmetic: gradient ของ L2 แปรตาม weight จึงหดลงเมื่อ weight หด เข้าใกล้ศูนย์แต่ไม่ถึง ขณะที่ gradient ของ L1 เป็นค่าคงที่ $\pm\lambda$ ที่ผลักต่อไปจนสุด L1 จึงสร้าง weight ที่เป็นศูนย์ เป๊ะ — มันเลือก feature L2 สร้าง weight ขนาดเล็ก ใช้ L2 เมื่อคุณต้องการความเรียบ ใช้ L1 เมื่อคุณต้องการ sparsity
Dropout⁷ ทำให้ activation บางส่วนที่สุ่มเลือกเป็นศูนย์ในแต่ละ training step เพื่อไม่ให้ unit ใดพึ่งพา unit อื่นตัวใดตัวหนึ่งว่าต้องมีอยู่
Early stopping เฝ้าดู validation loss และหยุดเมื่อมันหันขึ้น
Data augmentation สร้าง training example เพิ่มจากสิ่งที่คุณมี ซึ่งโจมตีปัญหาที่ต้นตอ: overfitting คือการขาด data พอ ๆ กับการมี parameter มากเกินไป
Cross-validation แบ่ง data เป็น $k$ ทางและ train $k$ ครั้ง ซึ่งซื้อ estimate ของ test error ที่เชื่อถือได้เมื่อคุณมี data น้อยเกินกว่าจะกัน held-out set ไว้

Double descent หรือทำไม section ก่อนหน้านี้จึงไม่ใช่เรื่องทั้งหมด

ลิงก์ไปยังส่วน: Double descent หรือทำไม section ก่อนหน้านี้จึงไม่ใช่เรื่องทั้งหมด

ตอนนี้คือข้อเท็จจริงที่ทำลายภาพนั้น

เรื่อง bias-variance บอกว่าหลังจุดพอดีไปแล้ว parameter มากขึ้นหมายถึง generalisation แย่ลง language model สมัยใหม่มี parameter มากกว่าที่กฎคลาสสิกอนุญาตมากเมื่อเทียบกับ data ที่มันเห็น และ generalise ได้ยอดเยี่ยม ทั้งสองประโยคเป็นจริง และการประสานมันเข้าด้วยกันคือสิ่งที่มีประโยชน์ที่สุดในบทนี้

training points 40 จุด input 20 มิติ random ReLU features และจำนวน feature $P$ sweep จาก 2 ถึง 5000 — โดยเลือก solution ที่มี minimum-norm ทุกครั้งเมื่อมีหลาย solution ที่ fit ได้:

$P$	$P/n$	train RMSE	test RMSE	$\lVert w \rVert$
10	0.25	0.8822	1.2520	1.89
20	0.50	0.5962	1.1634	2.59
30	0.75	0.3896	1.5323	4.15
38	0.95	0.1769	3.7163	10.25
40	1.00	0.0000	5.8140	14.83
42	1.05	0.0000	3.1623	9.35
60	1.50	0.0000	1.1058	2.78
200	5.00	0.0000	0.6638	0.98
1500	37.50	0.0000	0.5859	0.33
5000	125.00	0.0000	0.5664	0.18

อ่านเป็นสามส่วน ถึง $P/n = 0.5$ เรื่องคลาสสิกถูกต้องเป๊ะ: error ลดลง แล้วเริ่มสูงขึ้น ที่ $P = n = 40$ — interpolation threshold จุดที่ model มี parameter พอดีให้ผ่าน training point ทุกจุด — test error พุ่งถึงยอด ที่ 5.81 แย่กว่า model เล็กถึงห้าเท่า ยอดนี้คือคำเตือนแบบคลาสสิก และมันเป็นของจริง

จากนั้นมันลงอีกครั้ง และลงต่อไป ผ่าน $P = 5n$ ผ่าน $P = 37n$ ไปจนถึง $P = 125n$ ที่ test error 0.5664 ดีกว่าค่าที่ดีที่สุดที่ model แบบ under-parameterised เคยทำได้ model ที่มี 5000 parameters fit กับ 40 จุด เป็น model ที่ดีที่สุดในตาราง

นี่คือ double descent,⁸⁹ และ mechanism มองเห็นได้ในคอลัมน์สุดท้าย เมื่อ $P > n$ มีการตั้งค่า parameter อนันต์แบบที่ fit training data ได้เป๊ะ และคุณจะได้แบบไหนขึ้นกับว่าคุณเลือกอย่างไร solution แบบ minimum-norm เลือกตัวที่เล็กที่สุด และ $\lVert w \rVert$ แสดงว่านั่นหมายถึงอะไร: มัน peak ที่ 14.83 พอดีตรง threshold — จุดที่มี interpolating solution เพียงหนึ่งเดียวและคุณติดอยู่กับมัน ไม่ว่ามันจะสุดโต่งแค่ไหน — แล้วจากนั้น ลดลงแบบ monotonic เมื่อ $P$ โตขึ้น เพราะ parameter มากขึ้นหมายถึงมี interpolating solution ให้เลือกมากขึ้น ซึ่งหมายความว่า solution ที่เล็กที่สุดที่มีให้เลือกก็เล็กลง ที่ $P = 5000$ norm คือ 0.18 เล็กกว่าที่ threshold ถึงแปดสิบเท่า

ดังนั้น parameter ที่เพิ่มขึ้นไม่ได้เพิ่ม complexity แต่มันเพิ่ม ทางเลือก และ selection rule ใช้ทางเลือกนั้นไปกับความเรียบง่าย regularisation ไม่ได้อยู่ใน loss function แต่อยู่ใน algorithm gradient descent จาก initialisation เล็กมี bias ที่ถูกบันทึกไว้ว่ามุ่งไปหา solution ที่ norm เล็ก ซึ่งเป็นเหตุผลที่พฤติกรรมนี้ปรากฏใน network จริงที่ train ด้วยวิธีปกติ ไม่ใช่เฉพาะใน linear algebra ข้างบน

ผลเชิงปฏิบัติ ซึ่ง บทที่ 10 ต้องอาศัย: “model มี parameter มากกว่า data ดังนั้นมันจะ overfit” ไม่ใช่ argument ที่ใช้ได้ มันเคยเป็นกฎที่ดีเมื่อ model อยู่ทางซ้ายของ threshold ตอนนี้ทุกอย่างที่น่าสนใจอยู่ไกลทางขวาของมัน ซึ่งกฎกลับด้าน

ต่อไปจะไปที่ไหน

ลิงก์ไปยังส่วน: ต่อไปจะไปที่ไหน

เครื่องมือในบทนี้เพียงพอสำหรับการ train network ที่ใช้ได้กับ data ที่คุณใส่ในตารางได้: แถวของตัวเลข หนึ่งคอลัมน์ของ label

ภาษาไม่ใช่แบบนั้น ก่อนที่ model จะทำนายคำถัดไปได้ ต้องมีบางอย่างตัดสินก่อนว่า “คำ” คืออะไร — และคำตอบไม่ใช่ทั้งตัวอักษรหรือคำ แต่เป็น vocabulary ที่ model เรียนรู้จาก raw bytes ของ training data การตัดสินใจนั้น ซึ่งทำครั้งเดียวก่อน training เริ่ม กำหนดว่า model พูดได้กี่สิ่ง request หนึ่งราคาเท่าไร และทำไม model ที่สอบกฎหมายผ่านได้จึงนับตัวอักษรใน strawberry ได้ไม่เสถียร

บทที่ 7 สร้าง tokenizer

แหล่งที่มาและวิธีการ

ลิงก์ไปยังส่วน: แหล่งที่มาและวิธีการ

สำหรับ residual connections ที่ใช้ข้างบน ดู He et al., Deep Residual Learning for Image Recognition (arXiv:1512.03385) ส่วน Building makemore Part 3: Activations & Gradients, BatchNorm ของ Andrej Karpathy พาเดินผ่านการวินิจฉัย activation-histogram บน model จริง และเป็น treatment ภาคปฏิบัติที่ดีที่สุดของครึ่งแรกของบทนี้ lecture 8 และ 11–13 ใน Learning From Data ของ Yaser Abu-Mostafa อธิบายทฤษฎี generalisation แบบคลาสสิกอย่างถูกต้อง รวมถึงส่วนที่บทนี้บีบอัดเหลือหนึ่งย่อหน้า

รายการอ้างอิง

ลิงก์ไปยังส่วน: รายการอ้างอิง

Glorot, X. and Bengio, Y. Understanding the difficulty of training deep feedforward neural networks. AISTATS (2010). เหตุผลเรื่องการรักษา variance ที่นำมาแสดงซ้ำในกล่องข้างบน ↩
He, K., Zhang, X., Ren, S. and Sun, J. Delving Deep into Rectifiers: Surpassing Human-Level Performance on ImageNet Classification. arXiv:1502.01852 (2015). ↩
Ioffe, S. and Szegedy, C. Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift. arXiv:1502.03167 (2015). โปรดทราบว่าคำอธิบาย “internal covariate shift” ในชื่อเรื่องถูกโต้แย้งอย่างหนักในภายหลัง layer ใช้งานได้ แต่คำอธิบายดั้งเดิมว่าทำไมจึงใช้ได้ยังเป็นข้อถกเถียง ↩
Ba, J. L., Kiros, J. R. and Hinton, G. E. Layer Normalization. arXiv:1607.06450 (2016). ↩
Kingma, D. P. and Ba, J. Adam: A Method for Stochastic Optimization. arXiv:1412.6980 (2014). ↩
Loshchilov, I. and Hutter, F. Decoupled Weight Decay Regularization. arXiv:1711.05101 (2017). ↩
Srivastava, N., Hinton, G., Krizhevsky, A., Sutskever, I. and Salakhutdinov, R. Dropout: A Simple Way to Prevent Neural Networks from Overfitting. JMLR 15, pp. 1929–1958 (2014). ↩
Belkin, M., Hsu, D., Ma, S. and Mandal, S. Reconciling modern machine-learning practice and the classical bias–variance trade-off. PNAS 116(32), pp. 15849–15854 (2019). paper ที่ตั้งชื่อปรากฏการณ์นี้ ↩
Nakkiran, P., Kaplun, G., Bansal, Y., Yang, T., Barak, B. and Sutskever, I. Deep Double Descent: Where Bigger Models and More Data Hurt. arXiv:1912.02292 (2019). แสดง effect นี้ใน deep networks จริง และตามแกน training time เช่นเดียวกับแกน model size ↩

ทำไม network 6 ชั้นถึงตาย

Normalisation และแบบไหนที่รอด

แก้ทีละอย่าง ซึ่งคือ skill จริง

ทำให้คู่ควรกับ PyTorch

ทำไม Adam จึงมีอยู่: curvature

ครึ่งหลัง: model ที่ fit สมบูรณ์แบบแต่ทำนายอะไรไม่ได้

Double descent หรือทำไม section ก่อนหน้านี้จึงไม่ใช่เรื่องทั้งหมด

ต่อไปจะไปที่ไหน

แหล่งที่มาและวิธีการ

รายการอ้างอิง

พร้อมให้ LIA เลือกโมเดลให้แล้วหรือยัง?