اسے train کروانا، اور اسے generalise کروانا

اندازہ لگانے کے بجائے پہلے دیکھیں۔ inputs کا ایک batch آگے push کریں اور ہر layer پر activations کی standard deviation print کریں، پھر weight gradients کی standard deviation:

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:

پہلی row اوپر والا network ہے، اور یہ آہستہ نہیں سیکھ رہا — اس کے پاس signal بچا ہی نہیں۔ layer four تک activation standard deviation چار decimal places میں zero تک underflow ہو چکی ہے۔ ہر input ایک ہی output پیدا کرتا ہے، output ایک constant ہے، اور constant کا gradient کچھ نہیں ہوتا۔ weights کو "safe" رہنے کے لیے چھوٹا initialise کیا گیا تھا، اور چھوٹا ہونا مہلک نکلا۔

دوسری row الٹی failure ہے اور اسے سمجھنا ضروری ہے کیونکہ یہ counterintuitive ہے۔ activations صحت مند لگتی ہیں — تقریباً 0.96 — مگر یہ $\tanh$ saturated ہے، اپنی حد کے قریب pinned، بالکل وہی regime جسے باب 5 نے gradient میں تقریباً دس ہزار کے factor کی کمی کے طور پر measure کیا تھا۔ اس کے باوجود gradients بہت بڑے ہیں: پہلی layer پر 1940۔ دونوں باتیں ایک ساتھ درست ہیں۔ ہر backward step $W^\top$ سے multiply کرتا ہے، اور unit variance پر 128 inputs کے ساتھ اس factor کا gain تقریباً $\sqrt{128} \approx 11$ ہوتا ہے، جو saturated $\tanh$ سے آنے والی shrinkage پر غالب آ جاتا ہے۔ واپسی کے راستے پر gradients geometrically بڑھتے ہیں۔ یہ exploding gradient ہے، اور کسی بھی real training run میں چند steps کے اندر nan کے loss values پیدا کرتا ہے۔

تیسری row وہ ہے جو آپ چاہتے ہیں: activations depth کے پار scale میں تقریباً constant، gradients depth کے پار scale میں تقریباً constant۔ کچھ نہیں مرتا، کچھ نہیں پھٹتا۔

اچھی initialisation step zero پر scale fix کرتی ہے۔ یہ اسے fixed نہیں رکھتی: weights move کرتے ہیں، اور step five thousand تک careful variance argument مزید apply نہیں کرتا۔

Normalisation layers scale کو continuously enforce کرتی ہیں۔ activations کا ایک vector لے کر mean subtract کریں، standard deviation سے divide کریں، پھر learned scale $\gamma$ اور shift $\beta$ apply کریں تاکہ اگر layer کو normalisation undo کرنی ہو تو وہ کر سکے:

اصل سوال صرف یہ ہے کہ آپ average کس چیز پر لیتے ہیں۔ Batch normalisation³ batch dimension کے across $\mu$ اور $\sigma$ لیتی ہے، فی feature ایک statistic۔ Layer normalisation⁴ انہیں features کے across لیتی ہے، فی example ایک statistic۔

یہ choice معمولی لگتی ہے اور downstream تقریباً سب کچھ decide کر دیتی ہے:

اسی لیے LayerNorm وہ ہے جو آپ باب 9 میں بغیر بدلے دوبارہ دیکھیں گے: transformer block اسے استعمال کرتا ہے، اور دائیں ہاتھ والے column کی وجوہات کے لیے استعمال کرتا ہے، abstract میں بہتر کام کرنے کی وجہ سے نہیں۔

مردہ network کے لیے چار candidate fixes: Xavier initialisation، LayerNorm، residual connections، اور SGD کے بجائے Adam۔ temptation یہ ہے کہ چاروں apply کریں اور آگے بڑھ جائیں۔ ایسا کریں گے تو آپ کبھی نہیں جانیں گے کہ کون سی چیز mattered، اور اگلی بار جب ایسا ہوگا تو آپ کے پاس method نہیں ہوگی — صرف ritual ہوگا۔

اس لیے انہیں ایک وقت میں ایک apply کریں۔ وہی seed، وہی data، وہی architecture، 800 steps:

اس table کو ویسے پڑھیں جیسے آپ رات 2 بجے پڑھتے، اور conclusion یہ نکلتا ہے: اکیلے کچھ کام نہیں کرتا، سب کچھ ساتھ کام کرتا ہے، لہٰذا deep learning alchemy ہے۔ یہ conclusion غلط ہے، اور کیوں غلط ہے یہ جاننا اس باب کی سب سے useful چیز ہے۔

ہر run کو چھ گنا budget دیں — 800 کے بجائے 5000 steps — اور picture مکمل بدل جاتی ہے:

اب picture sharp ہے، اور یہ ritual نہیں بلکہ diagnosis ہے۔

Initialisation اکیلی اسے fix کر دیتی ہے۔ Normalisation اکیلی اسے fix کر دیتی ہے۔ دونوں اصل disease کو address کرتی ہیں — forward signal کا zero تک collapse ہونا — اور دونوں میں سے کوئی ایک کافی ہے۔ 800 steps پر وہ بس partial credit جیسی لگیں، کیونکہ انہوں نے problem solve کر دی تھی اور ابھی باہر نکل رہی تھیں۔

Residual connections اور Adam کسی بھی budget پر اسے fix نہیں کرتے۔ اس لیے نہیں کہ وہ bad ہیں، بلکہ اس لیے کہ وہ ایک مختلف disease treat کرتے ہیں۔ residual connection gradient کو blocking layer کے around ایک path دیتا ہے؛ یہ تب بہت قیمتی ہے جب gradient problem ہو، اور تب کچھ نہیں جب forward signal پہلے ہی zero ہو، کیونکہ dead layer کے around shortcut بھی dead value ہی carry کرتا ہے۔ Adam ہر parameter کے step کو اس کی اپنی gradient history سے rescale کرتا ہے؛ یہ تب help کرتا ہے جب gradients کی magnitudes بہت مختلف ہوں، اور ایسے network کو revive نہیں کر سکتا جس کا output اس کے input پر depend ہی نہیں کرتا۔

اور "nothing" پانچ ہزار steps کے بعد بھی exactly 0.6931 ہے۔ 0.6929 نہیں۔ یہ slow نہیں؛ یہ dead ہے، اور اب یہ distinction پہلے سے زیادہ visible ہے، کیونکہ compare کرنے کے لیے آپ کے پاس وہ row ہے جو کہتی ہے کہ fix کام کرتا ہے۔

یہاں سے آگے یہ course PyTorch استعمال کرتا ہے۔ یہ announce کرنے کے بجائے earn ہونا چاہیے، اس لیے یہ بالکل وہی ہے جو یہ کرتا ہے اور جو آپ پہلے ہی کرنا جانتے ہیں۔

optimiser ایک rule ہے جو gradients کو parameter updates میں بدلتا ہے۔ Plain gradient descent gradient استعمال کرتا ہے۔ Momentum اس کا running average استعمال کرتا ہے، جو noise smooth کرتا ہے اور ان directions میں speed build کرتا ہے جو consistent رہتی ہیں:

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

Adam⁵ دو running averages رکھتا ہے — gradient کا اور gradient squared کا — اور ایک کو دوسرے کے square root سے divide کرتا ہے، تاکہ ہر parameter کو اپنے recent gradient magnitude کے مطابق scaled step ملے:

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 پر torch.optim کے against 50 steps تک run کریں:

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 ہیں، plus edge cases پر decades کی care اور ایک C++ kernel۔ یہاں سے آگے آپ یہی trade کر رہے ہیں: سمجھ کے بدلے magic نہیں، بلکہ وہ lines جو آپ پہلے ہی لکھ چکے ہیں ان کے بدلے speed۔

Adam کی usual explanation "adaptive per-parameter learning rates" ہے، جو reason کے بجائے description ہے۔ reason geometry ہے، اور اسے measure کیا جا سکتا ہے۔

ایک ایسا loss لیں جس کی curvature directions کے درمیان مختلف ہو: ایک میں steep، دوسری میں shallow۔ SGD کے پاس ایک global learning rate ہوتا ہے، اس لیے اسے ایک ایسی value pick کرنی پڑتی ہے جو steepest direction میں stable رہنے کے لیے کافی small ہو — اور وہی value shallow direction کے لیے بہت ہی small ہو جاتی ہے، جہاں progress crawl کرتی ہے۔ یہی gradient descent کی narrow valley میں zig-zag کرتی classic تصویر کی وجہ ہے۔

دو curvature ratios، تین optimisers، 300 steps، اور ہر optimiser کو sweep سے best learning rate دیا گیا تاکہ کوئی handicapped نہ ہو:

دس کے ratio پر سب کچھ کام کرتا ہے اور discuss کرنے کو کچھ نہیں۔ ہزار پر، plain SGD آزمائے گئے کسی بھی learning rate پر answer تک نہیں پہنچ سکتا — اس کا best result بھی error 1.93 ہے — اور یہ آدھی rates پر outright diverge کرتا ہے۔ Adam target پر exactly land کرتا ہے اور کسی پر بھی diverge نہیں کرتا۔

آخری column Adam کے default ہونے کی practical وجہ ہے۔ ایسا نہیں کہ Adam بہتر solutions find کرتا ہے؛ well-conditioned problems پر tuned SGD اکثر اسے match یا beat کر دیتا ہے۔ وجہ یہ ہے کہ Adam آپ کے picked learning rate کے لیے کہیں کم sensitive ہے، اور real networks میں اپنے millions of parameters کے across curvature ratios ہزار سے کہیں بدتر ہوتے ہیں۔

دو مزید pieces یہاں belong کرتے ہیں اور دونوں ایک line ہیں۔ Gradient clipping جب بھی gradient vector کا norm threshold سے exceed کرے اسے rescale کر دیتی ہے، جس سے diagnostic table کی "loss suddenly jumps to a huge value" والی 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 کرنا جس پر start کیا تھا minimum کے around jitter کرنے کے برابر ہے، settle ہونے کے نہیں۔

اب تک سب کچھ loss down کرنے کے بارے میں تھا۔ اب زیادہ hard half، کیونکہ loss down ہونا goal نہیں — یہ goal کا proxy ہے، اور proxy ایک specific اور famous طریقے سے fail کرتا ہے۔

smooth function سے بارہ points جن میں تھوڑا noise ہے۔ increasing degree کے polynomials fit کریں:

Degree 11 بارہ points کے through ہر ایک سے exactly گزرتا ہے — train error چھ decimal places تک zero — اور unseen data پر degree 5 سے آٹھ گنا بدتر ہے۔ Degree 3 اور degree 11 سے $x = 3.25$ پر predict کرنے کو کہیں، training range سے ذرا باہر:

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 find کیا جائے — اوپر table میں degree 5۔

standard tools سب variance term پر attack کرتے ہیں:

• L2 regularisation (weight decay) loss میں $\lambda \lVert w \rVert^2$ add کرتی ہے، weights کو zero کی طرف pull کرتی ہے اور function کو smoother بناتی ہے۔ اوپر table میں degree 11 کا largest coefficient damage کرتا ہے؛ size کو penalise کرنا اسے defuse کرتا ہے۔
• L1 اس کے بجائے $\lambda \sum |w_i|$ add کرتی ہے۔ فرق cosmetic نہیں: L2 کا gradient weight کے proportional ہوتا ہے، اس لیے weight کے ساتھ shrink ہوتا ہے، zero کے قریب پہنچتا ہے مگر پہنچتا نہیں، جبکہ L1 کا gradient ایک constant $\pm\lambda$ ہے جو آخر تک push کرتا رہتا ہے۔ اس لیے L1 ایسے weights پیدا کرتی ہے جو exactly zero ہوتے ہیں — یہ features select کرتی ہے۔ L2 small weights پیدا کرتی ہے۔ smoothness چاہیے تو L2 استعمال کریں، sparsity چاہیے تو L1۔
• Dropout⁷ ہر training step پر activations کے random subset کو zero کرتا ہے، تاکہ کوئی unit کسی particular دوسرے unit کی موجودگی پر rely نہ کر سکے۔
• Early stopping validation loss دیکھتا ہے اور جب وہ اوپر مڑتا ہے تو stop کر دیتا ہے۔
• Data augmentation آپ کے موجود examples سے مزید training examples بناتا ہے، یعنی problem کو اس کے source پر attack کرتا ہے: overfitting اتنا ہی data کی shortage ہے جتنا parameters کی excess۔
• Cross-validation data کو $k$ ways میں split کرتا ہے اور $k$ times train کرتا ہے، جو test error کا reliable estimate خریدتا ہے جب آپ کے پاس held-out set spare کرنے کے لیے data بہت کم ہو۔

اب وہ fact جو picture کو توڑتا ہے۔

bias-variance story کہتی ہے کہ sweet spot کے بعد زیادہ parameters کا مطلب بدتر generalisation ہے۔ Modern language models کے پاس classical rules کی data کے حساب سے اجازت سے کہیں زیادہ parameters ہیں، اور وہ superbly generalise کرتے ہیں۔ دونوں statements درست ہیں، اور انہیں reconcile کرنا اس chapter کی سب سے useful چیز ہے۔

چالیس training points، بیس-dimensional inputs، random ReLU features، اور features کی تعداد $P$ کو 2 سے 5000 تک sweep کیا گیا — اور جب fit کرنے والے many solutions ہوں تو minimum-norm solution chosen کیا گیا:

اسے تین parts میں پڑھیں۔ $P/n = 0.5$ تک classical story exactly hold کرتی ہے: error گرتا ہے، پھر rising start کرتا ہے۔ $P = n = 40$ پر — interpolation threshold، جہاں model کے پاس ہر training point سے گزرنے کے لیے exactly کافی parameters ہوتے ہیں — test error peak کرتا ہے، 5.81 پر، small model سے پانچ گنا بدتر۔ یہ peak classical warning ہے، اور یہ real ہے۔

پھر یہ دوبارہ descend کرتا ہے۔ اور descend کرتا رہتا ہے، $P = 5n$ سے آگے، $P = 37n$ سے آگے، $P = 125n$ تک، جہاں 0.5664 کا test error best under-parameterised model کی achieved value سے بھی بہتر ہے۔ 40 points پر fit کیا گیا 5000 parameters والا model table کا best model ہے۔

یہ double descent ہے،⁸⁹ اور mechanism last column میں visible ہے۔ جب $P > n$ ہو تو infinitely many parameter settings training data کو exactly fit کرتی ہیں، اور آپ کو کون سی ملتی ہے یہ آپ کے choose کرنے کے طریقے پر depend کرتا ہے۔ minimum-norm solution smallest کو pick کرتا ہے، اور $\lVert w \rVert$ دکھاتا ہے کہ اس کا مطلب کیا ہے: یہ threshold پر exactly 14.83 تک peak کرتا ہے — جہاں exactly ایک interpolating solution ہے اور آپ اسی کے ساتھ stuck ہیں، چاہے وہ کتنا extreme ہو — اور پھر $P$ بڑھنے کے ساتھ monotonically fall کرتا ہے، کیونکہ زیادہ parameters کا مطلب choose کرنے کے لیے زیادہ interpolating solutions ہے، یعنی available smallest solution چھوٹا ہو جاتا ہے۔ $P = 5000$ پر norm 0.18 ہے، threshold سے اسی گنا چھوٹا۔

لہٰذا extra parameters complexity add نہیں کر رہے۔ وہ choice add کر رہے ہیں، اور selection rule اس choice کو simplicity پر spend کرتا ہے۔ regularisation loss function میں نہیں؛ algorithm میں ہے۔ small initialisation سے gradient descent کا small-norm solutions کی طرف documented bias ہے، اسی لیے یہ behaviour ordinary way میں train کیے گئے real networks میں بھی نظر آتا ہے، صرف اوپر والی linear algebra میں نہیں۔

practical consequence، جس پر باب 10 depend کرتا ہے: "model کے پاس data سے زیادہ parameters ہیں، اس لیے یہ overfit کرے گا" valid argument نہیں۔ یہ تب اچھی rule تھی جب models threshold کے left پر رہتے تھے۔ اب ہر interesting چیز threshold کے بہت right پر رہتی ہے، جہاں rule reverse ہو جاتی ہے۔

اس باب کے tools اتنے ہیں کہ آپ ایسا network train کر سکیں جو table میں رکھی جانے والی data پر کام کرے: numbers کی rows، labels کا ایک column۔

Language ایسی نہیں۔ model اگلا word predict کرنے سے پہلے، کسی چیز کو decide کرنا پڑتا ہے کہ "word" آخر ہے کیا — اور answer letters بھی نہیں اور words بھی نہیں، بلکہ ایک vocabulary ہے جو model training data کے raw bytes سے سیکھتا ہے۔ یہ decision، جو training شروع ہونے سے پہلے ایک بار لیا جاتا ہے، determine کرتا ہے کہ model کتنی چیزیں کہہ سکتا ہے، ایک request کی cost کتنی ہے، اور کیوں وہ models جو law exam pass کر سکتے ہیں strawberry کے letters reliably count نہیں کر سکتے۔

باب 7 ایک tokenizer بناتا ہے۔

اوپر استعمال کی گئی 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 walkthrough کرتا ہے اور اس chapter کے first half کا بہترین hands-on treatment ہے۔ Yaser Abu-Mostafa کی Learning From Data lectures 8 اور 11–13 classical generalisation theory proper دیتی ہیں، ان parts سمیت جنہیں اس chapter نے ایک paragraph میں compress کیا۔