6/30अध्याय 6 / 30

Train कराना, और Generalise कराना

छह-layer network जिसकी loss ln 2 से नहीं हिलती—एक-एक माप से ठीक की गई। फिर double descent: 40 points पर 5,000 parameters।

26 जून 2026अपडेट किया गया 11 सितंबर 202622 मिनट पढ़ें

इस पेज पर

Chapter 5 वाला network काम करता है। उसमें नौ parameters हैं, वह XOR सीखता है, और उसके gradients PyTorch से सोलह decimal places तक मेल खाते हैं.

इसे छह layers गहरा बनाइए और यह पूरी तरह सीखना बंद कर देता है। धीरे-धीरे नहीं — पूरी तरह। यहाँ two-spiral classification problem पर एक six-layer network है, जिसे 5000 steps तक train किया गया:

TEXT

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

यह संख्या मनमानी नहीं है। $\ln 2 = 0.693147$ उस model की binary cross-entropy है जो हर चीज़ के लिए probability $0.5$ output करता है, और balanced dataset पर 50 % coin flip है। पाँच हज़ार steps के बाद network एक भी digit नहीं हिला। कुछ crash नहीं हुआ, कोई warning नहीं आई, और gradients अब भी बिल्कुल सही हैं।

यह chapter उस gap के बारे में है जो चलने वाले network और काम करने वाले network के बीच होता है। इसके दो हिस्से हैं जो अलग subjects जैसे दिखते हैं, पर काम वही है: loss को नीचे ले जाना, और उसे उस data पर नीचे ले जाना जिसे model ने पहले कभी नहीं देखा।

छह-layer network dead क्यों है

सेक्शन का लिंक: छह-layer network dead क्यों है

अनुमान लगाने के बजाय देखना शुरू कीजिए। inputs का एक batch आगे pass कीजिए और हर layer पर activations का standard deviation print कीजिए, और फिर weight gradients का standard deviation:

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}")

तीन initialisations, वही architecture, $\tanh$ की छह layers:

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, पहली layer → आख़िरी
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

पहली row ऊपर वाला network है, और वह धीरे-धीरे नहीं सीख रहा — उसमें कोई signal बचा ही नहीं है। layer four तक activation standard deviation चार decimal places में zero तक underflow हो चुका है। हर input वही output बनाता है, output constant है, और constant का gradient कुछ नहीं होता। weights को "सुरक्षित रहने" के लिए छोटा initialise किया गया था, और छोटा होना fatal निकला।

दूसरी row उलटी failure है और इसे समझना ज़रूरी है क्योंकि यह counterintuitive है। activations स्वस्थ दिखते हैं — लगभग 0.96 — लेकिन यह $\tanh$ saturated है, अपनी limit के पास अटका हुआ, ठीक वही regime जिसे Chapter 5 ने gradient में लगभग दस हज़ार गुना कमी के रूप में measure किया था। फिर भी gradients बहुत बड़े हैं: पहली layer पर 1940। दोनों बातें एक साथ सच हैं। हर backward step $W^\top$ से multiply करता है, और unit variance वाले 128 inputs के साथ उस factor का gain लगभग $\sqrt{128} \approx 11$ होता है, जो saturated $\tanh$ से आने वाली shrinkage को overwhelm कर देता है। gradients वापस आते हुए geometrically बढ़ते हैं। यही exploding gradient है, और किसी भी वास्तविक training run में कुछ ही steps में nan जैसी loss values देता है।

तीसरी row वही है जो आप चाहते हैं: activations depth के पार लगभग constant scale में, gradients depth के पार लगभग constant scale में। कुछ मरता नहीं, कुछ explode नहीं करता।

initialisation formulas कहाँ से आते हैं, arithmetic के एक paragraph में।

एक unit $z = \sum_{i=1}^{n} w_i x_i$ compute करता है। अगर $w_i$ independent हैं और variance $\sigma_w^2$ है, और $x_i$ independent हैं और variance $\sigma_x^2$ है, तो sum का variance variances के sum के बराबर होता है:

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

Signal को एक layer से अगली layer तक वही scale बनाए रखने के लिए आप $\mathrm{Var}(z) = \sigma_x^2$ चाहते हैं, जो $\sigma_w^2 = 1/n$ को मजबूर करता है। पूरी derivation यही है। Glorot और Bengio¹ forward pass ( $n_{\text{in}}$ ) की constraint को backward pass ( $n_{\text{out}}$ ) वाली constraint के साथ average करते हैं, जिससे $\sigma_w^2 = 2/(n_{\text{in}} + n_{\text{out}})$ मिलता है — Xavier initialisation। He et al.² note करते हैं कि ReLU अपने inputs के आधे हिस्से को zero कर देता है, variance को आधा कर देता है, और $\sigma_w^2 = 2/n_{\text{in}}$ से compensate करते हैं — He initialisation, जिसे आप ReLU के साथ use करते हैं।

$n = 128$ के साथ, Xavier $\sigma_w \approx 0.088$ देता है। failing run ने $0.01$ use किया: कोई अलग philosophy नहीं, बल्कि nine का factor, और यही सीखने वाले network और न सीखने वाले network के बीच का फर्क था।

Normalisation, और कौन-सा बचा

सेक्शन का लिंक: Normalisation, और कौन-सा बचा

अच्छी initialisation step zero पर scale ठीक करती है। यह उसे fixed नहीं रखती: weights move करते हैं, और step five thousand तक careful variance argument लागू नहीं रहता।

Normalisation layers scale को continuously enforce करती हैं। activations का vector लें, mean subtract करें, standard deviation से divide करें, फिर learned scale $\gamma$ और shift $\beta$ apply करें ताकि layer normalisation को undo कर सके अगर उसे वही चाहिए:

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

असल सवाल सिर्फ़ यह है कि आप किस पर average करते हैं। Batch normalisation³ batch dimension के across $\mu$ और $\sigma$ लेता है, प्रति feature एक statistic। Layer normalisation⁴ उन्हें features के across लेता है, प्रति example एक statistic।

यह choice मामूली दिखती है और downstream लगभग सब कुछ तय कर देती है:

BatchNorm हर example के output को उन दूसरे examples पर depend कराता है जो संयोग से उसके batch में थे। training time पर यह mild regulariser है। inference time पर batch नहीं होता, इसलिए उसे training के दौरान collect की गई statistics का running average रखना पड़ता है — जिसका मतलब है कि layer training और evaluation mode में अलग behave करती है, और modes switch करना भूलना field में सबसे common bugs में से एक है। यह छोटे batches के साथ degrade भी करती है, और variable-length sequences के साथ awkward है, क्योंकि "position 40 पर batch का mean" उन्हीं sequences से compute होता है जो संयोग से उतनी लंबी हों।

LayerNorm हर example को अपने-आप normalise करता है। कोई batch dependence नहीं, कोई running statistics नहीं, training और inference में identical behaviour, batch size से indifferent, sequence length से indifferent। जब आप एक user के लिए एक समय में एक token generate कर रहे होते हैं — जहाँ Chapter 13 पहुँचता है — तो इनमें से हर property nicety नहीं, requirement बन जाती है।

इसीलिए LayerNorm वही है जिसे आप Chapter 9 में बिना बदले फिर देखेंगे: transformer block इसे use करता है, और right-hand column में दिए गए कारणों से use करता है, इसलिए नहीं कि abstract में यह बेहतर काम करता है।

एक-एक चीज़ ठीक करना, जो असली skill है

सेक्शन का लिंक: एक-एक चीज़ ठीक करना, जो असली skill है

dead network के लिए चार candidate fixes: Xavier initialisation, LayerNorm, residual connections, और SGD के बजाय Adam। temptation है कि चारों apply कर दें और आगे बढ़ जाएँ। ऐसा करेंगे तो कभी नहीं जानेंगे कि कौन-सी चीज़ मायने रखती थी, और अगली बार ऐसा होने पर आपके पास method नहीं होगा — केवल ritual होगा।

इसलिए उन्हें एक-एक करके apply करें। वही seed, वही data, वही architecture, 800 steps:

क्या जोड़ा गया	final loss	accuracy
कुछ नहीं	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 %
चारों	0.0000	100.0 %

उस table को वैसे पढ़िए जैसे आप उसे रात 2 बजे पढ़ते: निष्कर्ष होगा कि कुछ भी अकेले काम नहीं करता, सब साथ काम करते हैं, इसलिए deep learning alchemy है। यह निष्कर्ष गलत है, और क्यों गलत है यह पता लगाना इस chapter की सबसे उपयोगी चीज़ है।

हर run को छह गुना budget दें — 800 के बजाय 5000 steps — और तस्वीर पूरी तरह बदल जाती है:

क्या जोड़ा गया	final loss @ 5000	accuracy
कुछ नहीं	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 %

अब तस्वीर sharp है, और यह ritual नहीं बल्कि diagnosis है।

Initialisation अकेले इसे ठीक करती है। Normalisation अकेले इसे ठीक करती है। दोनों वास्तविक बीमारी को address करती हैं — forward signal का zero पर collapse होना — और कोई भी एक sufficient है। 800 steps पर वे केवल partial credit जैसी दिखीं, क्योंकि उन्होंने problem solve कर दी थी और अभी बाहर निकल रही थीं।

Residual connections और Adam इसे किसी भी budget पर ठीक नहीं करते। इसलिए नहीं कि वे खराब हैं, बल्कि इसलिए कि वे अलग बीमारी का इलाज करते हैं। residual connection gradient को blocking layer के around एक path देता है; जब problem gradient हो तो यह बहुत कीमती है, और जब forward signal पहले से zero हो तो बेकार, क्योंकि dead layer के around shortcut भी dead value ही carry करता है। Adam हर parameter के step को उसके अपने gradient history से rescale करता है; यह तब मदद करता है जब gradients के magnitudes बहुत अलग हों, और ऐसे network को resurrect नहीं कर सकता जिसका output अपने input पर depend नहीं करता।

और "nothing" पाँच हज़ार steps के बाद भी बिल्कुल 0.6931 है। 0.6929 नहीं। यह slow नहीं है; यह dead है, और वह distinction अब ऐसे visible है जैसे पहले नहीं था, क्योंकि compare करने के लिए आपके पास वह row है जो कहती है कि fix काम करता है।

Diagnostic table। Loss curves की shapes होती हैं, और shapes informative होती हैं। आगे search के लिए starting point है, diagnosis नहीं — लेकिन यह एक साथ चार चीज़ें बदलने से कहीं बेहतर starting point है।

loss क्या करती है	सबसे संभावित कारण	पहले क्या check करें
step 1 से $\ln 2$ (या $\ln k$ ) पर बिल्कुल flat	forward signal dead, या disconnected graph	हर layer पर activation std print करें; confirm करें कि `loss.backward()` non-zero `.grad` produce करता है
कुछ ही steps में `nan`	exploding gradients, या loss में `log(0)`	step से पहले gradient norm; numerically stable loss use करें (Chapter 4)
घटती है फिर huge value पर jump करती है	learning rate बहुत high, या एक bad batch	gradient clipping; per batch loss log करें और outlier ढूँढें
घटती है और high plateau पर रुकती है	underfitting, या learning rate अब बहुत छोटा	अधिक capacity, लंबा schedule, decay check करें
train loss नीचे, validation loss ऊपर	overfitting — इस chapter का दूसरा half	regularisation, early stopping, अधिक data
train loss नीचे लेकिन धीरे और noisily	batch बहुत छोटा, या learning rate schedule गलत	बड़ा batch, warmup
loss suspiciously तेज़ rate से नीचे जाती है	leak: target input में visible है, या training data पर evaluation	celebrate करने से पहले split audit करें

PyTorch कमाना

सेक्शन का लिंक: PyTorch कमाना

यहाँ से यह course PyTorch use करता है। इसे announce करने के बजाय earn करना चाहिए, इसलिए यहाँ ठीक-ठीक वह है जो यह करता है और जिसे करना आप पहले से जानते हैं।

Optimiser gradients को parameter updates में बदलने का rule है। Plain gradient descent gradient use करता है। Momentum उसका running average use करता है, जो noise को smooth करता है और उन directions में speed build करता है जो consistent रहती हैं:

optim_by_hand.pyPYTHON

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

Adam⁵ दो running averages रखता है — gradient का और gradient squared का — और एक को दूसरे के square root से divide करता है, ताकि हर parameter को उसके अपने recent gradient magnitude के हिसाब से scaled step मिले:

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)

दस lines। दोनों को उसी problem पर 50 steps के लिए torch.optim के against run करें:

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

float32 precision तक identical। torch.optim.Adam वही पाँच lines हैं, साथ में edge cases पर दशकों की care और एक C++ kernel। यहाँ से आप यही trade कर रहे हैं: understanding के बदले magic नहीं, बल्कि उन lines के बदले speed जो आप पहले ही लिख चुके हैं।

AdamW, और एक bug जो सालों तक हर framework में रहा। Adam को आमतौर पर weight decay के साथ combine किया जाता है — हर parameter को zero की ओर खींचना, जो L2 regularisation है। obvious implementation gradient में $\lambda w$ जोड़ता है। लेकिन Adam फिर उस combined gradient को $\sqrt{\hat{v}}$ से divide करता है, इसलिए किसी parameter को मिलने वाला decay उसके gradient history पर depend करता है: बड़े gradients वाले parameters कम decay होते हैं। यह किसी का intention नहीं था, और इससे decay coefficient SGD के साथ उसी coefficient से अलग behave करता है।

Loshchilov और Hutter⁶ ने दोनों को अलग किया, adaptive step के बाद decay को सीधे weights पर apply किया। यही AdamW है, language models train करने का default, और इसके exist करने की वजह idea और implementation के बीच mismatch है जो सालों तक सबके use करने के बावजूद survive करता रहा।

Adam क्यों exist करता है: curvature

सेक्शन का लिंक: Adam क्यों exist करता है: curvature

Adam की usual explanation "adaptive per-parameter learning rates" है, जो reason नहीं बल्कि description है। reason geometry है, और इसे measure किया जा सकता है।

ऐसी loss लें जिसकी curvature directions के बीच अलग हो: एक में steep, दूसरी में shallow। SGD के पास एक global learning rate होता है, इसलिए उसे इतना छोटा value चुनना पड़ता है कि steepest direction में stable रहे — और वही value shallow direction के लिए बहुत छोटा हो जाता है, जहाँ progress रेंगती है। यही gradient descent के narrow valley में zig-zag करते हुए नीचे उतरने वाली classic picture का कारण है।

दो curvature ratios, तीन optimisers, 300 steps, और हर optimiser को sweep से best learning rate दिया गया ताकि कोई handicapped न हो:

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 try किए गए किसी भी learning rate पर answer तक नहीं पहुँच सकता — उसका best result अब भी 1.93 error है — और आधे rates पर सीधे diverge करता है। Adam target पर बिल्कुल land करता है और उनमें से किसी पर diverge नहीं करता।

वह आख़िरी column व्यावहारिक वजह है कि Adam default है। ऐसा नहीं है कि Adam बेहतर solutions ढूँढता है; well-conditioned problems पर tuned SGD अक्सर उससे match करता है या beat करता है। बात यह है कि Adam आपके चुने हुए learning rate के प्रति बहुत कम sensitive है, और real networks में उनके millions of parameters के across curvature ratios एक हज़ार से कहीं worse होते हैं।

दो और pieces यहाँ belong करते हैं और दोनों one line हैं। Gradient clipping gradient vector को rescale करता है जब भी उसका norm threshold से ऊपर जाता है, जिससे diagnostic table की "loss अचानक huge value पर jump करती है" row non-event बन जाती है। और learning rate schedules: पहले कुछ hundred steps में near-zero से एक short warmup, क्योंकि Adam के variance estimates तब तक garbage होते हैं जब तक उन्होंने कुछ gradients न देख लिए हों और garbage पर लिया गया full-size step initialisation को wreck कर सकता है; फिर zero की ओर cosine decay, क्योंकि run को उसी step size पर end करना जिससे आपने शुरू किया था, minimum में settle होने के बजाय उसके around jitter करना है।

दूसरा half: model जो perfectly fit करता है और कुछ predict नहीं करता

सेक्शन का लिंक: दूसरा half: model जो perfectly fit करता है और कुछ predict नहीं करता

अब तक सब कुछ loss नीचे लाने के बारे में था। अब कठिन half, क्योंकि loss का नीचे जाना goal नहीं है — वह goal का proxy है, और proxy एक specific और famous तरीके से fail करता है।

थोड़े noise वाली smooth function से बारह points। increasing degree के polynomials fit करें:

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

12 points के through degree 11 हर single point से exactly गुजरता है — train error six decimal places तक zero — और unseen data पर degree 5 से आठ गुना worse है। degree 3 और degree 11 से $x = 3.25$ पर predict करने को कहिए, training range के ठीक बाहर:

TEXT

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

इकसठ, जहाँ answer लगभग zero है। model ने function नहीं सीखा; उसने बारह points सीखे, और उनके बीच वह वही करता है जो arithmetic demand करती है।

यह overfitting है, और इसका opposite — degree 1, जो curve को represent ही नहीं कर सकता और हर जगह bad है — underfitting है। Classical account किसी model की expected error को तीन parts में split करता है: bias, वह error जो model के truth को represent करने के लिए बहुत rigid होने से आता है; variance, वह error जो model के इतना flexible होने से आता है कि वह इस particular sample के noise का पीछा करता है; और irreducible noise, जिसे कुछ भी fix नहीं करता। Simple models biased होते हैं, flexible models high-variance होते हैं, और classical prescription बीच का sweet spot खोजना है — ऊपर की table में degree 5।

Standard tools सभी variance term पर attack करते हैं:

L2 regularisation (weight decay) loss में $\lambda \lVert w \rVert^2$ जोड़ता है, weights को zero की ओर खींचता है और function को smoother बनाता है। ऊपर की table में degree 11 का largest coefficient damage करता है; size को penalise करना उसे defuse करता है।
L1 इसके बजाय $\lambda \sum |w_i|$ जोड़ता है। फर्क cosmetic नहीं है: L2 का gradient weight के proportional होता है और इसलिए weight के घटने पर shrink होता है, बिना पहुँचे zero के पास जाता है, जबकि L1 का gradient constant $\pm\lambda$ होता है जो पूरा रास्ता push करता रहता है। इसलिए L1 ऐसे weights produce करता है जो exactly zero होते हैं — यह features select करता है। L2 small weights produce करता है। smoothness चाहिए तो L2 use करें, sparsity चाहिए तो L1।
Dropout⁷ हर training step पर activations के random subset को zero करता है, ताकि कोई unit किसी particular दूसरे unit के present होने पर rely न कर सके।
Early stopping validation loss देखता है और जब वह ऊपर मुड़ती है तो stop कर देता है।
Data augmentation आपके पास मौजूद examples से और training examples बनाता है, जो problem के source पर attack करता है: overfitting उतना ही data की कमी है जितना parameters की excess।
Cross-validation data को $k$ ways में split करता है और $k$ बार train करता है, जिससे test error का reliable estimate मिलता है जब आपके पास held-out set अलग रखने के लिए बहुत कम data हो।

Double descent, या पिछला section पूरी कहानी क्यों नहीं है

सेक्शन का लिंक: Double descent, या पिछला section पूरी कहानी क्यों नहीं है

अब वह fact जो picture तोड़ता है।

bias-variance story कहती है कि sweet spot के बाद, अधिक parameters का मतलब worse generalisation है। Modern language models के पास उनके देखे data के लिए classical rules से कहीं अधिक parameters होते हैं, और वे superbly generalise करते हैं। ये दोनों statements सच हैं, और उन्हें reconcile करना इस chapter की सबसे उपयोगी चीज़ है।

चालीस training points, twenty-dimensional inputs, random ReLU features, और features की संख्या $P$ को 2 से 5000 तक sweep किया गया — जब भी fit करने वाली कई solutions हों, minimum-norm solution चुना गया:

$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

इसे तीन parts में पढ़िए। $P/n = 0.5$ तक classical story बिल्कुल hold करती है: error गिरता है, फिर rise करना शुरू करता है। $P = n = 40$ पर — interpolation threshold, जहाँ model के पास हर training point से गुजरने के लिए exactly enough parameters होते हैं — test error peak करता है, 5.81 पर, small model से पाँच गुना worse। वह peak classical warning है, और real है।

फिर यह फिर descends करता है। और descending जारी रखता है, $P = 5n$ से past, $P = 37n$ से past, पूरी तरह $P = 125n$ तक, जहाँ 0.5664 का test error best under-parameterised model द्वारा कभी हासिल किए गए result से बेहतर है। 40 points पर fit किया गया 5000 parameters वाला model table का best model है।

यह double descent है,⁸⁹ और mechanism last column में visible है। एक बार $P > n$ हो जाए तो parameter settings की infinitely many choices होती हैं जो training data को exactly fit करती हैं, और आपको कौन-सी मिलती है यह इस पर depend करता है कि आप कैसे choose करते हैं। minimum-norm solution smallest चुनता है, और $\lVert w \rVert$ दिखाता है कि इसका क्या मतलब है: threshold पर यह 14.83 तक peak करता है — जहाँ exactly one interpolating solution है और आप उसी के साथ stuck हैं, चाहे वह कितना भी extreme हो — और फिर $P$ बढ़ने पर monotonically गिरता है, क्योंकि अधिक parameters का मतलब चुनने के लिए अधिक interpolating solutions है, यानी smallest available solution और छोटा हो जाता है। $P = 5000$ पर norm 0.18 है, threshold से अस्सी गुना छोटा।

तो extra parameters complexity नहीं जोड़ रहे। वे choice जोड़ रहे हैं, और selection rule उस choice को simplicity पर खर्च करता है। regularisation loss function में नहीं है; algorithm में है। छोटी initialisation से gradient descent का small-norm solutions की ओर documented bias है, इसलिए यह behaviour real networks में भी दिखता है जो ordinary way से train किए जाते हैं, केवल ऊपर की linear algebra में नहीं।

Practical consequence, जिस पर Chapter 10 depend करता है: "model के पास data से अधिक parameters हैं, इसलिए यह overfit करेगा" valid argument नहीं है। यह अच्छा rule था जब models threshold के left में रहते थे। अब interesting सब कुछ उसके बहुत right में रहता है, जहाँ rule reverse हो जाता है।

आगे क्या

सेक्शन का लिंक: आगे क्या

इस chapter के tools उस network को train करने के लिए पर्याप्त हैं जो table में रखे जा सकने वाले data पर काम करता है: numbers की rows, labels का एक column।

Language वैसी नहीं है। इससे पहले कि model next word predict कर सके, किसी चीज़ को decide करना होगा कि "word" आखिर है क्या — और answer न letters है न words, बल्कि एक vocabulary है जिसे model training data के raw bytes से सीखता है। यह decision, training शुरू होने से पहले एक बार लिया गया, तय करता है कि model कितनी चीज़ें कह सकता है, request की cost कितनी है, और क्यों वे models जो law exam pass कर सकते हैं, strawberry में letters reliably count नहीं कर पाते।

Chapter 7 tokenizer बनाता है।

Sources and method

सेक्शन का लिंक: Sources and method

ऊपर use किए गए residual connections के लिए, He et al., Deep Residual Learning for Image Recognition (arXiv:1512.03385). Andrej Karpathy का Building makemore Part 3: Activations & Gradients, BatchNorm real model पर activation-histogram diagnostic के through चलता है और इस chapter के first half का best hands-on treatment है। Yaser Abu-Mostafa की Learning From Data lectures 8 और 11–13 classical generalisation theory को properly देती हैं, उन parts सहित जिन्हें इस chapter ने एक paragraph में compress किया है।

संदर्भ

सेक्शन का लिंक: संदर्भ

Glorot, X. and Bengio, Y. Understanding the difficulty of training deep feedforward neural networks. AISTATS (2010). ऊपर box में variance-preservation argument reproduce किया गया है। ↩
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). Note करें कि title में दी गई "internal covariate shift" explanation पर बाद में काफी dispute हुआ है; layer काम करती है, पर क्यों करती है इसका original account contested है। ↩
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 जिसने phenomenon को नाम दिया। ↩
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). real deep networks में effect दिखाता है, और model size axis के साथ-साथ training time axis पर भी। ↩

छह-layer network dead क्यों है

Normalisation, और कौन-सा बचा

एक-एक चीज़ ठीक करना, जो असली skill है

PyTorch कमाना

Adam क्यों exist करता है: curvature

दूसरा half: model जो perfectly fit करता है और कुछ predict नहीं करता

Double descent, या पिछला section पूरी कहानी क्यों नहीं है

आगे क्या

Sources and method

संदर्भ

मॉडल चुनने का काम LIA पर छोड़ने के लिए तैयार हैं?