وادار کردن شبکه به آموزش، و وادار کردنش به تعمیم

به‌جای حدس زدن، با نگاه کردن شروع کنید. یک batch از ورودی‌ها را عبور دهید و انحراف معیار activationها را در هر لایه چاپ کنید، و بعد انحراف معیار gradientهای وزن‌ها را:

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، یک معماری، شش لایه از $\tanh$:

ردیف اول همان شبکه‌ی بالاست، و این شبکه کند یاد نمی‌گیرد — دیگر هیچ سیگنالی برایش باقی نمانده است. تا لایه‌ی چهارم، انحراف معیار activation در چهار رقم اعشار به صفر underflow کرده است. هر ورودی همان خروجی را تولید می‌کند، خروجی یک ثابت است، و gradient یک ثابت چیزی نیست. وزن‌ها «برای احتیاط» کوچک initialised شده بودند، و کوچک بودن کشنده بود.

ردیف دوم شکستِ برعکس است و ارزش فهمیدن دارد چون خلاف شهود است. activationها سالم به نظر می‌رسند — حوالی 0.96 — اما این همان $\tanh$ اشباع‌شده است، چسبیده نزدیک حد خود، دقیقاً همان ناحیه‌ای که فصل 5 اندازه گرفت و دید gradient تقریباً ده هزار برابر از دست می‌رود. بااین‌حال gradientها عظیم‌اند: 1940 در لایه‌ی اول. هر دو چیز هم‌زمان درست‌اند. هر گام backward در $W^\top$ ضرب می‌کند، و با 128 ورودی در واریانس واحد، آن عامل gain حدود $\sqrt{128} \approx 11$ دارد، که کوچک‌شدن ناشی از $\tanh$ اشباع‌شده را غرق می‌کند. gradientها در مسیر برگشت به‌صورت هندسی رشد می‌کنند. این همان exploding gradient است، و در هر اجرای واقعی آموزش، ظرف چند گام lossهای nan تولید می‌کند.

ردیف سوم همان چیزی است که می‌خواهید: activationها در عمق تقریباً مقیاس ثابت دارند، gradientها در عمق تقریباً مقیاس ثابت دارند. چیزی نمی‌میرد، چیزی منفجر نمی‌شود.

initialisation خوب مقیاس را در گام صفر درست می‌کند. آن را ثابت نگه نمی‌دارد: وزن‌ها حرکت می‌کنند، و تا گام پنج‌هزارم، استدلال دقیق واریانس دیگر برقرار نیست.

لایه‌های normalisation مقیاس را پیوسته اعمال می‌کنند. با داشتن برداری از activationها، یک میانگین را کم کنید، بر یک انحراف معیار تقسیم کنید، سپس یک مقیاسِ آموخته‌شده‌ی $\gamma$ و یک جابه‌جاییِ $\beta$ اعمال کنید تا اگر لایه خواست normalisation را خنثی کند بتواند:

تنها پرسش واقعی این است که روی چه چیزی میانگین می‌گیرید. Batch normalisation³، $\mu$ و $\sigma$ را روی بُعد batch می‌گیرد، یک آمار برای هر feature. Layer normalisation⁴ آن‌ها را روی featureها می‌گیرد، یک آمار برای هر مثال.

این انتخاب کوچک به نظر می‌رسد و تقریباً همه‌چیزِ بعدی را تعیین می‌کند:

به همین دلیل است که LayerNorm همان چیزی است که دوباره در فصل 9 بدون تغییر می‌بینید: بلوک transformer از آن استفاده می‌کند، و به دلایل ستون سمت راست از آن استفاده می‌کند، نه چون در انتزاع بهتر کار می‌کند.

چهار راه‌حل پیشنهادی برای شبکه‌ی مرده: Xavier initialisation، LayerNorm، residual connectionها، و Adam به‌جای SGD. وسوسه این است که هر چهار تا را اعمال کنید و بروید جلو. این کار را بکنید و هرگز نمی‌فهمید کدام‌یک مهم بوده، و دفعه‌ی بعد که اتفاق بیفتد روش نخواهید داشت — فقط یک آیین.

پس یکی‌یکی اعمالشان کنید. همان seed، همان داده، همان معماری، 800 گام:

این جدول را همان‌طور بخوانید که ساعت 2 صبح می‌خوانید، و نتیجه این می‌شود: هیچ‌چیز به‌تنهایی کار نمی‌کند، همه‌چیز با هم کار می‌کند، پس deep learning کیمیاست. این نتیجه غلط است، و فهمیدن چرایش مفیدترین بخش این فصل است.

به هر اجرا شش برابر بودجه بدهید — 5000 گام به‌جای 800 — و تصویر کاملاً عوض می‌شود:

حالا تصویر تیز است، و تشخیص است نه آیین.

initialisation به‌تنهایی درستش می‌کند. normalisation به‌تنهایی درستش می‌کند. هرکدام بیماری واقعی را هدف می‌گیرد — collapse شدن سیگنال forward به صفر — و هرکدام کافی است. در 800 گام فقط شبیه امتیاز جزئی به نظر می‌رسیدند، چون مسئله را حل کرده بودند و هنوز داشتند از چاله بیرون می‌آمدند.

residual connectionها و Adam، در هیچ بودجه‌ای درستش نمی‌کنند. نه چون بد هستند، بلکه چون بیماری دیگری را درمان می‌کنند. residual connection مسیری برای gradient دورِ یک لایه‌ی مسدودکننده فراهم می‌کند؛ وقتی مشکل gradient باشد ارزش زیادی دارد، و وقتی سیگنال forward از قبل صفر است هیچ ارزشی ندارد، چون میان‌بُرِ دور یک لایه‌ی مرده هنوز مقدار مرده حمل می‌کند. Adam اندازه‌ی گام هر پارامتر را با تاریخچه‌ی gradient خودش بازتنظیم می‌کند؛ وقتی gradientها اندازه‌های بسیار متفاوت دارند کمک می‌کند، و نمی‌تواند شبکه‌ای را زنده کند که خروجی‌اش به ورودی‌اش وابسته نیست.

و «هیچ‌چیز» هنوز بعد از پنج هزار گام دقیقاً 0.6931 است. نه 0.6929. کند نیست؛ مرده است، و این تمایز حالا به شکلی دیده می‌شود که قبلاً دیده نمی‌شد، چون ردیفی دارید که می‌گوید یک اصلاح کار می‌کند و می‌توانید با آن مقایسه کنید.

از اینجا به بعد، این دوره از PyTorch استفاده می‌کند. این باید به‌دست بیاید، نه اینکه فقط اعلام شود؛ پس دقیقاً اینجاست که PyTorch همان کاری را انجام می‌دهد که شما از قبل بلد هستید.

optimiser قاعده‌ای است برای تبدیل gradientها به به‌روزرسانی پارامترها. gradient descent ساده از gradient استفاده می‌کند. Momentum از میانگین متحرک آن استفاده می‌کند، که نویز را هموار می‌کند و در جهت‌هایی که سازگار می‌مانند سرعت می‌سازد:

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

Adam⁵ دو میانگین متحرک نگه می‌دارد — یکی از gradient و یکی از مربع gradient — و یکی را بر ریشه‌ی دوم دیگری تقسیم می‌کند، تا هر پارامتر گامی متناسب با اندازه‌ی gradient اخیر خودش بگیرد:

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 گام اجرا کنید:

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 یکسان‌اند. torch.optim.Adam همان پنج خط است، به‌علاوه‌ی دهه‌ها مراقبت درباره‌ی edge caseها و یک kernel در C++. معامله‌ای که از اینجا به بعد می‌کنید همین است: نه جادو به‌جای فهم، بلکه سرعت به‌جای خط‌هایی که از قبل نوشته‌اید.

توضیح معمول Adam این است: «learning rateهای adaptive برای هر پارامتر»، که توصیف است نه دلیل. دلیل هندسه است، و می‌توان آن را اندازه گرفت.

lossی را در نظر بگیرید که انحنایش میان جهت‌ها فرق دارد: در یکی تند، در دیگری کم‌شیب. SGD یک learning rate سراسری دارد، پس باید مقداری را انتخاب کند که در تندترین جهت پایدار باشد — و همان مقدار برای جهت کم‌شیب بسیار کوچک است، جایی که پیشرفت می‌خزد. این همان چیزی است که تصویر کلاسیکِ زیگزاگ زدن gradient descent در یک دره‌ی باریک را می‌سازد.

دو نسبت انحنا، سه optimiser، 300 گام، و برای هر optimiser بهترین learning rate از یک sweep داده شده تا کسی handicapped نباشد:

در نسبت ده، همه‌چیز کار می‌کند و چیزی برای بحث نیست. در هزار، SGD ساده در هیچ‌یک از learning rateهای امتحان‌شده به جواب نمی‌رسد — بهترین نتیجه‌اش هنوز error برابر 1.93 است — و در نیمی از rateها صریحاً diverge می‌کند. Adam دقیقاً روی target فرود می‌آید و در هیچ‌کدام diverge نمی‌کند.

آن ستون آخر دلیل عملی default بودن Adam است. مسئله این نیست که Adam راه‌حل‌های بهتری پیدا می‌کند؛ در مسائل well-conditioned، SGD تنظیم‌شده اغلب با آن برابری می‌کند یا شکستش می‌دهد. مسئله این است که Adam نسبت به learning rateی که انتخاب کرده‌اید بسیار کم‌حساس‌تر است، و شبکه‌های واقعی در میلیون‌ها پارامترشان نسبت‌های انحنایی بسیار بدتر از هزار دارند.

دو قطعه‌ی دیگر هم اینجا جای دارند و هر دو یک خط‌اند. Gradient clipping هرگاه norm بردار gradient از آستانه‌ای بگذرد، آن را rescale می‌کند، و ردیف «loss ناگهان به مقدار عظیمی می‌پرد» در جدول تشخیص را به یک اتفاق بی‌اهمیت تبدیل می‌کند. و learning rate scheduleها: یک warmup کوتاه از نزدیک صفر طی چند صد گام اول، چون برآوردهای واریانس Adam تا وقتی چند gradient ندیده‌اند آشغال‌اند و یک گام کامل روی آشغال می‌تواند initialisation را خراب کند؛ سپس cosine decay به سمت صفر، چون تمام کردن یک اجرا با همان اندازه‌گامی که شروع کرده‌اید یعنی لرزیدن دور minimum به‌جای نشستن در آن.

تا اینجا همه‌چیز درباره‌ی پایین آوردن loss بود. حالا نیمه‌ی سخت‌تر، چون پایین آمدن loss هدف نیست — proxy هدف است، و این proxy به شکلی مشخص و مشهور شکست می‌خورد.

دوازده نقطه از تابعی smooth با کمی نویز. polynomialهایی با درجه‌های فزاینده fit کنید:

درجه‌ی 11 از میان 12 نقطه تک‌تک آن‌ها را دقیقاً عبور می‌دهد — train error تا شش رقم اعشار صفر — و روی داده‌ای که ندیده، هشت برابر بدتر از درجه‌ی 5 است. از درجه‌ی 3 و درجه‌ی 11 بخواهید در $x = 3.25$، کمی بیرون از بازه‌ی training، پیش‌بینی کنند:

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

شصت‌ویک، درحالی‌که جواب تقریباً صفر است. مدل تابع را یاد نگرفت؛ دوازده نقطه را یاد گرفت، و بین آن‌ها هر کاری را می‌کند که حساب‌وکتاب اقتضا کند.

این overfitting است، و نقطه‌ی مقابلش — درجه‌ی 1، که اصلاً نمی‌تواند منحنی را نمایش دهد و همه‌جا بد است — underfitting است. روایت کلاسیک، خطای مورد انتظار مدل را به سه بخش تقسیم می‌کند: bias، خطایی که از بیش از حد صلب بودن مدل برای نمایش حقیقت می‌آید؛ variance، خطایی که از آن می‌آید که مدل آن‌قدر انعطاف‌پذیر است که نویز همین نمونه‌ی خاص را دنبال می‌کند؛ و نویز کاهش‌ناپذیر، که هیچ‌چیز درستش نمی‌کند. مدل‌های ساده biased هستند، مدل‌های انعطاف‌پذیر high-variance هستند، و نسخه‌ی کلاسیک این است که نقطه‌ی شیرین وسط را پیدا کنید — درجه‌ی 5 در جدول بالا.

ابزارهای استاندارد همگی به جمله‌ی variance حمله می‌کنند:

• L2 regularisation (weight decay) عبارت $\lambda \lVert w \rVert^2$ را به loss اضافه می‌کند، وزن‌ها را به سمت صفر می‌کشد و تابع را smoothتر می‌کند. در جدول بالا، بزرگ‌ترین ضریب درجه‌ی 11 خسارت را می‌زند؛ جریمه کردن اندازه آن را خنثی می‌کند.
• L1 به‌جای آن $\lambda \sum |w_i|$ را اضافه می‌کند. تفاوت cosmetic نیست: gradient در L2 متناسب با وزن است و بنابراین با کوچک شدن وزن کوچک می‌شود، به صفر نزدیک می‌شود بی‌آنکه برسد، درحالی‌که gradient در L1 یک ثابتِ $\pm\lambda$ است که تا آخر به هل دادن ادامه می‌دهد. بنابراین L1 وزن‌هایی تولید می‌کند که دقیقاً صفرند — feature انتخاب می‌کند. L2 وزن‌های کوچک تولید می‌کند. وقتی smoothness می‌خواهید از L2 استفاده کنید، وقتی sparsity می‌خواهید از L1.
• Dropout⁷ در هر گام آموزش، یک زیرمجموعه‌ی تصادفی از activationها را صفر می‌کند، تا هیچ واحدی نتواند روی حضور یک واحد خاص دیگر حساب کند.
• Early stopping، validation loss را تماشا می‌کند و وقتی رو به بالا برگردد متوقف می‌شود.
• Data augmentation از مثال‌هایی که دارید مثال‌های training بیشتری می‌سازد، و مسئله را از سرچشمه هدف می‌گیرد: overfitting به همان اندازه که زیادیِ پارامتر است، کمبود داده هم هست.
• Cross-validation داده را به $k$ بخش تقسیم می‌کند و $k$ بار آموزش می‌دهد، که وقتی داده‌تان آن‌قدر کم است که نمی‌توانید یک held-out set کنار بگذارید، برآورد قابل اتکایی از test error می‌خرد.

حالا واقعیتی که تصویر را می‌شکند.

داستان bias-variance می‌گوید بعد از نقطه‌ی شیرین، پارامترهای بیشتر یعنی generalisation بدتر. مدل‌های زبانی مدرن نسبت به قواعد کلاسیک، برای داده‌ای که می‌بینند پارامترهای بسیار بیشتری دارند، و عالی generalise می‌کنند. هر دو گزاره درست‌اند، و آشتی دادنشان مفیدترین چیز این فصل است.

چهل نقطه‌ی training، ورودی‌های بیست‌بعدی، featureهای تصادفی ReLU، و تعداد featureهای $P$ که از 2 تا 5000 sweep شده — با انتخاب راه‌حل minimum-norm هرجا راه‌حل‌های زیادی برای fit وجود دارد:

آن را در سه بخش بخوانید. تا $P/n = 0.5$ داستان کلاسیک دقیقاً برقرار است: error پایین می‌آید، بعد شروع به بالا رفتن می‌کند. در $P = n = 40$ — interpolation threshold، جایی که مدل دقیقاً به اندازه‌ی کافی پارامتر دارد تا از هر نقطه‌ی training عبور کند — test error به قله می‌رسد، 5.81، پنج برابر بدتر از مدل کوچک. آن قله همان هشدار کلاسیک است، و واقعی است.

بعد دوباره پایین می‌آید. و همچنان پایین می‌آید، از $P = 5n$ می‌گذرد، از $P = 37n$ می‌گذرد، تا $P = 125n$، جایی که test error برابر 0.5664 بهتر از بهترین مدلی است که در حالت under-parameterised به دست آمد. مدلی با 5000 پارامتر که روی 40 نقطه fit شده، بهترین مدل جدول است.

این double descent است،⁸⁹ و سازوکارش در ستون آخر دیده می‌شود. وقتی $P > n$، بی‌نهایت تنظیم پارامتر وجود دارد که داده‌ی training را دقیقاً fit می‌کند، و اینکه کدام‌یک را می‌گیرید به نحوه‌ی انتخاب شما بستگی دارد. راه‌حل minimum-norm کوچک‌ترین را انتخاب می‌کند، و $\lVert w \rVert$ نشان می‌دهد این یعنی چه: درست در threshold به 14.83 می‌رسد — جایی که دقیقاً یک راه‌حل interpolating وجود دارد و هرقدر هم extreme باشد با همان گیر می‌افتید — و بعد با رشد $P$ به‌صورت یکنواخت پایین می‌آید، چون پارامترهای بیشتر یعنی راه‌حل‌های interpolating بیشتری برای انتخاب، یعنی کوچک‌ترین گزینه‌ی موجود کوچک‌تر می‌شود. در $P = 5000$، norm برابر 0.18 است، هشتاد برابر کوچک‌تر از threshold.

پس پارامترهای اضافه complexity اضافه نمی‌کنند. آن‌ها انتخاب اضافه می‌کنند، و قاعده‌ی انتخاب این انتخاب را صرف سادگی می‌کند. regularisation در تابع loss نیست؛ در الگوریتم است. gradient descent از یک initialisation کوچک، bias مستندی به سمت راه‌حل‌های small-norm دارد، و به همین دلیل این رفتار در شبکه‌های واقعی که به روش معمول آموزش می‌بینند هم ظاهر می‌شود، نه فقط در جبر خطی بالا.

پیامد عملی، که فصل 10 به آن وابسته است: «مدل از داده پارامترهای بیشتری دارد، پس overfit می‌کند» استدلال معتبری نیست. وقتی مدل‌ها سمت چپ threshold زندگی می‌کردند، قاعده‌ی خوبی بود. حالا همه‌چیز جالب بسیار سمت راست آن زندگی می‌کند، جایی که قاعده برعکس می‌شود.

ابزارهای این فصل برای آموزش شبکه‌ای که روی داده‌ی جدولی کار کند کافی‌اند: ردیف‌هایی از عددها، ستونی از برچسب‌ها.

زبان این نیست. پیش از آنکه مدل بتواند واژه‌ی بعدی را پیش‌بینی کند، چیزی باید تصمیم بگیرد اصلاً «واژه» چیست — و جواب نه حرف‌هاست نه واژه‌ها، بلکه واژگانی است که مدل از byteهای خام داده‌ی training یاد می‌گیرد. این تصمیم، که یک بار پیش از شروع آموزش گرفته می‌شود، تعیین می‌کند مدل چند چیز می‌تواند بگوید، هزینه‌ی یک درخواست چقدر است، و چرا مدل‌هایی که می‌توانند در آزمون حقوق قبول شوند نمی‌توانند حروف strawberry را قابل‌اعتماد بشمارند.

فصل 7 یک tokenizer می‌سازد.

برای residual connectionهای استفاده‌شده در بالا، He و همکاران، Deep Residual Learning for Image Recognition (arXiv:1512.03385). اثر Andrej Karpathy با عنوان Building makemore Part 3: Activations & Gradients, BatchNorm تشخیص histogram activation را روی یک مدل واقعی قدم‌به‌قدم نشان می‌دهد و بهترین درمان عملی نیمه‌ی اول این فصل است. درس‌های 8 و 11–13 از Learning From Data اثر Yaser Abu-Mostafa نظریه‌ی کلاسیک generalisation را درست ارائه می‌کنند، از جمله بخش‌هایی که این فصل در یک پاراگراف فشرده کرد.