Πώς το κάνετε να εκπαιδευτεί — και να γενικεύσει

Ξεκινήστε κοιτάζοντας, αντί να μαντεύετε. Περάστε ένα batch εισόδων από το δίκτυο και εκτυπώστε την τυπική απόκλιση των activations σε κάθε επίπεδο, και μετά την τυπική απόκλιση των gradients των βαρών:

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

Τρεις αρχικοποιήσεις, ίδια αρχιτεκτονική, έξι επίπεδα $\tanh$:

Η πρώτη σειρά είναι το παραπάνω δίκτυο, και δεν μαθαίνει αργά — δεν του έχει απομείνει καθόλου σήμα. Στο τέταρτο επίπεδο, η τυπική απόκλιση των activations έχει υπορρεύσει στο μηδέν στα τέσσερα δεκαδικά ψηφία. Κάθε είσοδος παράγει την ίδια έξοδο, η έξοδος είναι σταθερά, και το gradient μιας σταθεράς είναι τίποτα. Τα βάρη αρχικοποιήθηκαν μικρά «για ασφάλεια», και το μικρό ήταν μοιραίο.

Η δεύτερη σειρά είναι η αντίθετη αποτυχία, και αξίζει να την καταλάβετε γιατί είναι αντιδιαισθητική. Τα activations φαίνονται υγιή — γύρω στο 0.96 — αλλά αυτό είναι $\tanh$ κορεσμένο, καρφωμένο κοντά στο όριό του, ακριβώς το καθεστώς που στο Κεφάλαιο 5 μετρήθηκε ως απώλεια σχεδόν δέκα χιλιάδων φορές στο gradient. Κι όμως τα gradients είναι τεράστια: 1940 στο πρώτο επίπεδο. Και τα δύο ισχύουν ταυτόχρονα. Κάθε backward βήμα πολλαπλασιάζει με $W^\top$, και με 128 εισόδους σε μοναδιαία διακύμανση αυτός ο παράγοντας έχει ενίσχυση περίπου $\sqrt{128} \approx 11$, η οποία υπερνικά τη συρρίκνωση από το κορεσμένο $\tanh$. Τα gradients αυξάνονται γεωμετρικά στην επιστροφή. Αυτό είναι το exploding gradient, και παράγει τιμές απώλειας nan μέσα σε λίγα βήματα σε οποιαδήποτε πραγματική εκπαίδευση.

Η τρίτη σειρά είναι αυτό που θέλετε: activations περίπου σταθερής κλίμακας σε όλο το βάθος, gradients περίπου σταθερής κλίμακας σε όλο το βάθος. Τίποτα δεν πεθαίνει, τίποτα δεν εκρήγνυται.

Η καλή αρχικοποίηση διορθώνει την κλίμακα στο βήμα μηδέν. Δεν τη διατηρεί σταθερή: τα βάρη μετακινούνται, και μέχρι το βήμα πέντε χιλιάδες το προσεκτικό επιχείρημα διακύμανσης δεν ισχύει πια.

Τα επίπεδα κανονικοποίησης επιβάλλουν την κλίμακα συνεχώς. Δεδομένου ενός διανύσματος activations, αφαιρείτε έναν μέσο όρο, διαιρείτε με μια τυπική απόκλιση, και μετά εφαρμόζετε μια μαθημένη κλίμακα $\gamma$ και μετατόπιση $\beta$ ώστε το επίπεδο να μπορεί να αναιρέσει την κανονικοποίηση αν αυτό αποδειχθεί πως θέλει:

Το μόνο πραγματικό ερώτημα είναι πάνω σε τι παίρνετε μέσο όρο. Το batch normalisation³ παίρνει τα $\mu$ και $\sigma$ κατά μήκος της διάστασης του batch, ένα στατιστικό ανά feature. Το layer normalisation⁴ τα παίρνει κατά μήκος των features, ένα στατιστικό ανά παράδειγμα.

Αυτή η επιλογή φαίνεται μικρή και αποφασίζει σχεδόν όλα όσα ακολουθούν:

Γι’ αυτό το LayerNorm είναι αυτό που θα ξανασυναντήσετε στο Κεφάλαιο 9 αμετάβλητο: το transformer block το χρησιμοποιεί, και το χρησιμοποιεί για τους λόγους της δεξιάς στήλης, όχι επειδή δουλεύει καλύτερα αφηρημένα.

Τέσσερις υποψήφιες διορθώσεις για το νεκρό δίκτυο: Xavier initialisation, LayerNorm, residual connections και Adam αντί για SGD. Ο πειρασμός είναι να εφαρμόσετε και τα τέσσερα και να προχωρήσετε. Κάντε το και δεν θα μάθετε ποτέ ποιο είχε σημασία, και την επόμενη φορά που θα συμβεί δεν θα έχετε μέθοδο — μόνο τελετουργικό.

Άρα εφαρμόστε τα ένα ένα. Ίδιο seed, ίδια δεδομένα, ίδια αρχιτεκτονική, 800 βήματα:

Διαβάστε αυτόν τον πίνακα όπως θα τον διαβάζατε στις 2 τα ξημερώματα και το συμπέρασμα είναι: τίποτα δεν δουλεύει μόνο του, όλα δουλεύουν μαζί, άρα το deep learning είναι αλχημεία. Αυτό το συμπέρασμα είναι λάθος, και το να μάθετε γιατί είναι το πιο χρήσιμο πράγμα σε αυτό το κεφάλαιο.

Δώστε σε κάθε εκτέλεση έξι φορές το budget — 5000 βήματα αντί για 800 — και η εικόνα αλλάζει τελείως:

Τώρα η εικόνα είναι καθαρή, και είναι διάγνωση αντί για τελετουργικό.

Η αρχικοποίηση μόνη της το διορθώνει. Η κανονικοποίηση μόνη της το διορθώνει. Καθεμία αντιμετωπίζει την πραγματική ασθένεια — την κατάρρευση του forward σήματος στο μηδέν — και οποιαδήποτε από τις δύο αρκεί. Στα 800 βήματα απλώς έμοιαζαν με μερική επιτυχία, επειδή είχαν λύσει το πρόβλημα και ακόμη ανέβαιναν από τον πάτο.

Τα residual connections και το Adam δεν το διορθώνουν, σε κανένα budget. Όχι επειδή είναι κακά, αλλά επειδή θεραπεύουν άλλη ασθένεια. Ένα residual connection δίνει στο gradient ένα μονοπάτι γύρω από ένα μπλοκαρισμένο επίπεδο· αυτό αξίζει πολύ όταν το πρόβλημα είναι το gradient, και δεν αξίζει τίποτα όταν το forward σήμα είναι ήδη μηδέν, επειδή μια παράκαμψη γύρω από ένα νεκρό επίπεδο εξακολουθεί να μεταφέρει νεκρή τιμή. Το Adam επανακλιμακώνει το βήμα κάθε παραμέτρου με βάση το δικό της ιστορικό gradients· αυτό βοηθά όταν τα gradients έχουν πολύ διαφορετικά μεγέθη, και δεν μπορεί να αναστήσει ένα δίκτυο του οποίου η έξοδος δεν εξαρτάται από την είσοδό του.

Και το «τίποτα» εξακολουθεί να είναι ακριβώς 0.6931 μετά από πέντε χιλιάδες βήματα. Όχι 0.6929. Δεν είναι αργό· είναι νεκρό, και αυτή η διάκριση είναι πλέον ορατή με τρόπο που δεν ήταν πριν, επειδή έχετε τη σειρά που λέει ότι μια διόρθωση δουλεύει για να τη συγκρίνετε.

Από εδώ και πέρα αυτό το μάθημα χρησιμοποιεί PyTorch. Αυτό πρέπει να κερδηθεί, όχι απλώς να ανακοινωθεί, οπότε να ακριβώς τι κάνει που ήδη ξέρετε πώς να κάνετε.

Ένας optimiser είναι ένας κανόνας για τη μετατροπή gradients σε ενημερώσεις παραμέτρων. Το απλό 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 cases και έναν C++ kernel. Αυτή είναι η ανταλλαγή που κάνετε από εδώ και πέρα: όχι μαγεία αντί κατανόησης, αλλά ταχύτητα αντί για γραμμές που έχετε ήδη γράψει.

Η συνηθισμένη εξήγηση του Adam είναι «adaptive learning rates ανά παράμετρο», που είναι περιγραφή και όχι λόγος. Ο λόγος είναι η γεωμετρία, και μπορεί να μετρηθεί.

Πάρτε μια απώλεια της οποίας η καμπυλότητα διαφέρει ανά κατεύθυνση: απότομη σε μία, ρηχή σε άλλη. Το SGD έχει ένα καθολικό learning rate, άρα πρέπει να επιλέξει μια τιμή αρκετά μικρή ώστε να είναι σταθερή στην πιο απότομη κατεύθυνση — και αυτή η τιμή είναι τότε υπερβολικά μικρή για τη ρηχή, όπου η πρόοδος σέρνεται. Αυτό προκαλεί την κλασική εικόνα του gradient descent που κάνει ζιγκ-ζαγκ κατεβαίνοντας μια στενή κοιλάδα.

Δύο λόγοι καμπυλότητας, τρεις optimisers, 300 βήματα, και σε κάθε optimiser δίνεται το καλύτερο learning rate από sweep ώστε κανείς να μην αδικείται:

Σε λόγο δέκα, όλα δουλεύουν και δεν υπάρχει τίποτα να συζητήσουμε. Στο χίλια, το απλό SGD δεν μπορεί να φτάσει την απάντηση σε κανένα learning rate που δοκιμάστηκε — το καλύτερο αποτέλεσμά του εξακολουθεί να είναι σφάλμα 1.93 — και αποκλίνει καθαρά στα μισά rates. Το Adam προσγειώνεται ακριβώς στον στόχο και δεν αποκλίνει σε κανένα.

Αυτή η τελευταία στήλη είναι ο πρακτικός λόγος που το Adam είναι το default. Δεν είναι ότι το Adam βρίσκει καλύτερες λύσεις· σε καλά ρυθμισμένα προβλήματα, το tuned SGD συχνά το ισοφαρίζει ή το ξεπερνά. Είναι ότι το Adam είναι πολύ λιγότερο ευαίσθητο στο learning rate που επιλέξατε, και τα πραγματικά δίκτυα έχουν λόγους καμπυλότητας πολύ χειρότερους από χίλια στις εκατομμύρια παραμέτρους τους.

Δύο ακόμη κομμάτια ανήκουν εδώ και είναι και τα δύο μία γραμμή. Το gradient clipping επανακλιμακώνει το διάνυσμα gradient όποτε το norm του ξεπερνά ένα κατώφλι, μετατρέποντας τη σειρά «η απώλεια ξαφνικά πηδά σε τεράστια τιμή» του διαγνωστικού πίνακα σε μη συμβάν. Και τα learning rate schedules: ένα σύντομο warmup από σχεδόν μηδέν στα πρώτα λίγες εκατοντάδες βήματα, επειδή οι εκτιμήσεις διακύμανσης του Adam είναι σκουπίδια μέχρι να δουν μερικά gradients και ένα πλήρους μεγέθους βήμα πάνω σε σκουπίδια μπορεί να καταστρέψει μια αρχικοποίηση· μετά cosine decay προς το μηδέν, επειδή το να τελειώνετε μια εκτέλεση με το ίδιο μέγεθος βήματος με το οποίο ξεκινήσατε σημαίνει ότι τρέμετε γύρω από το ελάχιστο αντί να κατασταλάζετε σε αυτό.

Όλα μέχρι τώρα αφορούσαν το να κατεβάσετε την απώλεια. Τώρα το δυσκολότερο μισό, επειδή η μείωση της απώλειας δεν είναι ο στόχος — είναι proxy για τον στόχο, και το proxy αποτυγχάνει με συγκεκριμένο και διάσημο τρόπο.

Δώδεκα σημεία από μια ομαλή συνάρτηση με λίγο θόρυβο. Προσαρμόστε πολυώνυμα αυξανόμενου βαθμού:

Ο βαθμός 11 μέσα από 12 σημεία περνά από κάθε ένα ακριβώς — train error μηδέν μέχρι έξι δεκαδικά ψηφία — και είναι οκτώ φορές χειρότερος από τον βαθμό 5 σε δεδομένα που δεν έχει δει. Ζητήστε από τον βαθμό 3 και τον βαθμό 11 να προβλέψουν στο $x = 3.25$, λίγο έξω από το training range:

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

Εξήντα ένα, εκεί όπου η απάντηση είναι περίπου μηδέν. Το μοντέλο δεν έμαθε τη συνάρτηση· έμαθε τα δώδεκα σημεία, και ανάμεσά τους κάνει ό,τι απαιτεί η αριθμητική.

Αυτό είναι overfitting, και το αντίθετό του — βαθμός 1, που δεν μπορεί να αναπαραστήσει καθόλου την καμπύλη και είναι κακό παντού — είναι underfitting. Η κλασική περιγραφή χωρίζει το αναμενόμενο σφάλμα ενός μοντέλου σε τρία μέρη: bias, το σφάλμα επειδή το μοντέλο είναι υπερβολικά άκαμπτο για να αναπαραστήσει την αλήθεια· variance, το σφάλμα επειδή το μοντέλο είναι τόσο ευέλικτο που κυνηγά τον θόρυβο στο συγκεκριμένο δείγμα· και μη αναγώγιμος θόρυβος, που δεν διορθώνεται με τίποτα. Τα απλά μοντέλα είναι biased, τα ευέλικτα μοντέλα έχουν υψηλό variance, και η κλασική συνταγή είναι να βρείτε το γλυκό σημείο στη μέση — βαθμός 5 στον παραπάνω πίνακα.

Τα τυπικά εργαλεία επιτίθενται όλα στον όρο variance:

• Το L2 regularisation (weight decay) προσθέτει $\lambda \lVert w \rVert^2$ στην απώλεια, τραβώντας τα βάρη προς το μηδέν και κάνοντας τη συνάρτηση πιο ομαλή. Στον παραπάνω πίνακα, ο μεγαλύτερος συντελεστής του βαθμού 11 κάνει τη ζημιά· η ποινή στο μέγεθος τον εξουδετερώνει.
• Το L1 προσθέτει αντί γι’ αυτό $\lambda \sum |w_i|$. Η διαφορά δεν είναι αισθητική: το gradient του L2 είναι ανάλογο του βάρους και άρα μικραίνει καθώς μικραίνει το βάρος, πλησιάζοντας το μηδέν χωρίς να φτάνει, ενώ το gradient του L1 είναι μια σταθερά $\pm\lambda$ που συνεχίζει να σπρώχνει μέχρι τέλους. Το L1 επομένως παράγει βάρη που είναι ακριβώς μηδέν — επιλέγει features. Το L2 παράγει μικρά βάρη. Χρησιμοποιήστε L2 όταν θέλετε ομαλότητα, L1 όταν θέλετε αραιότητα.
• Το Dropout⁷ μηδενίζει ένα τυχαίο υποσύνολο activations σε κάθε training step, ώστε καμία μονάδα να μην μπορεί να βασίζεται στην παρουσία οποιασδήποτε συγκεκριμένης άλλης μονάδας.
• Το Early stopping παρακολουθεί το validation loss και σταματά όταν αυτό γυρίζει προς τα πάνω.
• Το Data augmentation κατασκευάζει περισσότερα training examples από αυτά που έχετε, επιτιθέμενο στο πρόβλημα στην πηγή του: το overfitting είναι έλλειψη δεδομένων όσο και περίσσεια παραμέτρων.
• Το Cross-validation χωρίζει τα δεδομένα με $k$ τρόπους και εκπαιδεύει $k$ φορές, αγοράζοντας μια αξιόπιστη εκτίμηση του test error όταν έχετε πολύ λίγα δεδομένα για να κρατήσετε ξεχωριστό held-out set.

Τώρα το γεγονός που σπάει την εικόνα.

Η ιστορία bias-variance λέει ότι μετά το γλυκό σημείο, περισσότερες παράμετροι σημαίνουν χειρότερη γενίκευση. Τα σύγχρονα language models έχουν πολύ περισσότερες παραμέτρους από όσες επιτρέπουν οι κλασικοί κανόνες για τα δεδομένα που βλέπουν, και γενικεύουν εξαιρετικά. Και οι δύο προτάσεις είναι αληθείς, και η συμφιλίωσή τους είναι το πιο χρήσιμο πράγμα σε αυτό το κεφάλαιο.

Σαράντα training points, είσοδοι είκοσι διαστάσεων, τυχαία ReLU features, και ο αριθμός features $P$ σαρωμένος από 2 έως 5000 — με τη λύση minimum-norm να επιλέγεται όποτε υπάρχουν πολλές που ταιριάζουν:

Διαβάστε το σε τρία μέρη. Μέχρι το $P/n = 0.5$, η κλασική ιστορία ισχύει ακριβώς: το σφάλμα πέφτει και μετά αρχίζει να ανεβαίνει. Στο $P = n = 40$ — το interpolation threshold, όπου το μοντέλο έχει ακριβώς αρκετές παραμέτρους για να περάσει από κάθε training point — το test error κορυφώνεται, στο 5.81, πέντε φορές χειρότερο από το μικρό μοντέλο. Αυτή η κορυφή είναι η κλασική προειδοποίηση, και είναι πραγματική.

Μετά κατεβαίνει ξανά. Και συνεχίζει να κατεβαίνει, πέρα από το $P = 5n$, πέρα από το $P = 37n$, μέχρι το $P = 125n$, όπου το test error 0.5664 είναι καλύτερο από ό,τι πέτυχε ποτέ το καλύτερο under-parameterised μοντέλο. Ένα μοντέλο με 5000 παραμέτρους προσαρμοσμένο σε 40 σημεία είναι το καλύτερο μοντέλο στον πίνακα.

Αυτό είναι double descent,⁸⁹ και ο μηχανισμός είναι ορατός στην τελευταία στήλη. Μόλις $P > n$ υπάρχουν άπειρες ρυθμίσεις παραμέτρων που ταιριάζουν ακριβώς στα training data, και ποια θα πάρετε εξαρτάται από το πώς επιλέγετε. Η λύση minimum-norm επιλέγει τη μικρότερη, και το $\lVert w \rVert$ δείχνει τι σημαίνει αυτό: κορυφώνεται στο 14.83 ακριβώς στο threshold — όπου υπάρχει ακριβώς μία interpolating λύση και είστε κολλημένοι με αυτήν, όσο ακραία κι αν είναι — και μετά πέφτει μονοτονικά καθώς το $P$ μεγαλώνει, επειδή περισσότερες παράμετροι σημαίνουν περισσότερες interpolating λύσεις για να επιλέξετε, πράγμα που σημαίνει ότι η μικρότερη διαθέσιμη γίνεται μικρότερη. Στο $P = 5000$ το norm είναι 0.18, ογδόντα φορές μικρότερο από ό,τι στο threshold.

Άρα οι επιπλέον παράμετροι δεν προσθέτουν πολυπλοκότητα. Προσθέτουν επιλογή, και ο κανόνας επιλογής ξοδεύει αυτή την επιλογή στην απλότητα. Το regularisation δεν βρίσκεται στη συνάρτηση απώλειας· βρίσκεται στον αλγόριθμο. Το gradient descent από μικρή αρχικοποίηση έχει τεκμηριωμένο bias προς λύσεις μικρού norm, γι’ αυτό αυτή η συμπεριφορά εμφανίζεται σε πραγματικά δίκτυα εκπαιδευμένα με τον συνηθισμένο τρόπο και όχι μόνο στη γραμμική άλγεβρα παραπάνω.

Η πρακτική συνέπεια, από την οποία εξαρτάται το Κεφάλαιο 10: «το μοντέλο έχει περισσότερες παραμέτρους από δεδομένα, άρα θα κάνει overfit» δεν είναι έγκυρο επιχείρημα. Ήταν καλός κανόνας όταν τα μοντέλα ζούσαν αριστερά του threshold. Όλα τα ενδιαφέροντα πράγματα τώρα ζουν πολύ δεξιά του, όπου ο κανόνας αντιστρέφεται.

Τα εργαλεία σε αυτό το κεφάλαιο αρκούν για να εκπαιδεύσετε ένα δίκτυο που δουλεύει σε δεδομένα που μπορείτε να βάλετε σε πίνακα: σειρές αριθμών, μια στήλη ετικετών.

Η γλώσσα δεν είναι αυτό. Πριν ένα μοντέλο μπορέσει να προβλέψει την επόμενη λέξη, κάτι πρέπει να αποφασίσει τι είναι καν μια «λέξη» — και η απάντηση δεν είναι ούτε γράμματα ούτε λέξεις, αλλά ένα λεξιλόγιο που το μοντέλο μαθαίνει από τα raw bytes των training data. Αυτή η απόφαση, που λαμβάνεται μία φορά πριν αρχίσει η εκπαίδευση, καθορίζει πόσα πράγματα μπορεί να πει το μοντέλο, πόσο κοστίζει ένα αίτημα, και γιατί μοντέλα που μπορούν να περάσουν εξετάσεις νομικής δεν μπορούν να μετρήσουν αξιόπιστα τα γράμματα στο 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 περνά βήμα βήμα από το διαγνωστικό ιστόγραμμα activations σε πραγματικό μοντέλο και είναι η καλύτερη πρακτική αντιμετώπιση του πρώτου μισού αυτού του κεφαλαίου. Οι διαλέξεις 8 και 11–13 του Learning From Data του Yaser Abu-Mostafa δίνουν σωστά την κλασική θεωρία γενίκευσης, συμπεριλαμβανομένων των μερών που αυτό το κεφάλαιο συμπύκνωσε σε μία παράγραφο.