Attention και το transformer block, παραγμένα από έναν μέσο όρο

Από το 1997 έως περίπου το 2017, η σύνοψη ήταν μια recurrent κατάσταση: κρατήστε ένα vector $\mathbf{h}$ και ενημερώστε το σε κάθε token, $\mathbf{h}_t = f(\mathbf{h}_{t-1}, \mathbf{x}_t)$. Σταθερό μέγεθος, μεταβλητή είσοδος, ακριβώς το σωστό σχήμα.

Απέτυχε με τρεις τρόπους, και η αρχιτεκτονική αυτού του κεφαλαίου απαντά και στους τρεις. Το backpropagation μέσα από $T$ βήματα πολλαπλασιάζει $T$ Jacobians, οπότε το gradient εξαφανίζεται ή εκρήγνυται — η ασθένεια που το Κεφάλαιο 5 μέτρησε μέσα σε έναν μόνο κόμβο $\tanh$. Το LSTM¹ σχεδιάστηκε ακριβώς εναντίον αυτού και έσπρωξε το χρήσιμο εύρος από δεκάδες βήματα σε εκατοντάδες, χωρίς να αλλάξει το γεγονός ότι η πληροφορία από το token 5 φτάνει στο token 500 μόνο επιβιώνοντας 495 διαδοχικές ενημερώσεις. Όλη η πηγή έπρεπε να χωρέσει σε ένα vector: στη sequence-to-sequence μετάφραση², ένας encoder συμπιέζει την είσοδο στην τελική του κατάσταση. Οι Bahdanau, Cho και Bengio ονόμασαν αυτό το σημείο συμφόρησης και το διόρθωσαν το 2014, τρία χρόνια πριν από το transformer, αφήνοντας τον decoder να παίρνει ένα σταθμισμένο άθροισμα όλων των καταστάσεων του encoder με βάρη που υπολόγιζε ο ίδιος.³ Όλα παρακάτω είναι αυτή η ιδέα, εφαρμοσμένη από μια ακολουθία στον εαυτό της, με τη recurrence διαγραμμένη. Και η ενημέρωση είναι σειριακή από κατασκευής: το $\mathbf{h}_t$ χρειάζεται το $\mathbf{h}_{t-1}$, και μια GPU με δέκα χιλιάδες πυρήνες δεν μπορεί να κάνει τίποτα με αυτό. Η αρχιτεκτονική που κέρδισε δεν είναι προφανώς εξυπνότερη· είναι εκείνη της οποίας το ακριβό βήμα είναι ένας πολλαπλασιασμός πινάκων.

Το άλλο κλασικό inductive bias, convolution — σύρετε ένα μικρό φίλτρο πάνω από όλη την είσοδο, ώστε ένα χαρακτηριστικό που ανιχνεύεται οπουδήποτε να ανιχνεύεται παντού — δεν χτίζεται ούτε εδώ· είναι σχεδόν ακριβώς σωστό για εικόνες και ανατίθεται σε ένα μάθημα όρασης. Ούτε η recurrence ούτε το convolution επανεμφανίζονται μετά από αυτή τη σελίδα, γι’ αυτό κανένα από τα δύο δεν παίρνει κεφάλαιο: το Κεφάλαιο 1 υποσχέθηκε ότι οι παραλείψεις θα δηλώνονται, όχι θα κρύβονται.

Η πιο προφανής συνάρτηση μεταβλητού αριθμού vectors που επιστρέφει ένα vector είναι ο μέσος όρος:

Οποιοσδήποτε αριθμός εισόδων, σταθερό μέγεθος εξόδου, διαφορίσιμη, δωρεάν. Ένας embedding πίνακας συν αυτός ο μέσος όρος συν ένα linear layer προς το λεξιλόγιο είναι ένα πλήρες language model σε δεκαπέντε γραμμές. Είναι επίσης απαίσιο, και ο τρόπος με τον οποίο είναι απαίσιο είναι όλη η παραγώγιση.

Το corpus παρακάτω είναι ένα megabyte Shakespeare, 1.115.394 χαρακτήρες, μέσα από έναν byte-level BPE tokenizer του είδους που χτίστηκε στο Κεφάλαιο 7 με λεξιλόγιο 1024: 459.760 tokens με 2,43 χαρακτήρες το καθένα, χωρισμένα 90/10. Κάθε μοντέλο έχει πλάτος 128, βλέπει 128 tokens, και εκπαιδεύεται για 3000 βήματα AdamW στο $10^{-3}$ με batch 64. Το perplexity είναι στο held-out split.⁴

Διαβάστε τη δεύτερη γραμμή δύο φορές. Ο μέσος όρος του context δεν βοηθά λίγο· κάνει το μοντέλο τέσσερις φορές χειρότερο από το να αγνοεί εντελώς το context. Δύο λόγοι, και οι δύο αποδείξιμοι αντί για εμπειρικοί.

Ο μέσος όρος δεν μπορεί να δει σειρά. Η πρόσθεση είναι αντιμεταθετική, οπότε το ανακάτεμα του window αφήνει τη σύνοψη αμετάβλητη — όχι περίπου:

A = torch.tril(torch.ones(T, T))
A = A / A.sum(1, keepdim=True)          # rows of the averaging matrix
y = x[torch.randperm(T)]                # the same tokens, shuffled
print((A[-1] @ x - A[-1] @ y).abs().max().item())

2.9802322387695312e-08

Θόρυβος floating-point σε ένα άθροισμα με άλλη σειρά: οι δύο συνόψεις είναι το ίδιο vector. Ένα μοντέλο του οποίου η μόνη θέα στο context είναι ένας μέσος όρος δεν μπορεί να διακρίνει το ο σκύλος δάγκωσε τον άντρα από το ο άντρας δάγκωσε τον σκύλο. Η τρίτη γραμμή αποδεικνύει ότι αυτό δεν διορθώνεται προσθέτοντας θέσεις στις εισόδους — ένα learned position embedding σε κάθε token πριν από τον μέσο όρο αγόρασε 2,14 μονάδες από τις 188. Οι θέσεις μπαίνουν στο άθροισμα, και το άθροισμα τις ξεχνά.

Και ο μέσος όρος πνίγει το παρόν. Στη θέση 100, το τρέχον token είναι το ένα εκατοστό της σύνοψης. Αυτό έχει μια φθηνή διόρθωση που ήδη έχετε: κρατήστε το token και προσθέστε τη σύνοψη σε αυτό — μια residual connection, από το Κεφάλαιο 6, και η τέταρτη γραμμή δείχνει τι κάνει. Με τη διάλυση διορθωμένη, ο ομοιόμορφος μέσος όρος δεν συνεισφέρει απολύτως τίποτα: 60.45 έναντι baseline 59.71. Κάθε token είναι εκεί μέσα, με ίσο βάρος, και η ίση στάθμιση είναι το ίδιο με καμία πληροφορία.

Το πρόβλημα δεν είναι ο μέσος όρος. Είναι τα βάρη.

Ο μέσος όρος πάνω σε ένα αυξανόμενο πρόθεμα μοιάζει με loop. Είναι ένας πολλαπλασιασμός με έναν κάτω τριγωνικό πίνακα του οποίου οι γραμμές αθροίζουν σε ένα — και επίσης, ακριβώς, ένα softmax:

loop = torch.stack([x[:t + 1].mean(0) for t in range(T)])   # the obvious version

A = torch.tril(torch.ones(T, T))
A = A / A.sum(1, keepdim=True)
mat = A @ x                                                  # the same thing

S = torch.zeros(T, T).masked_fill(torch.tril(torch.ones(T, T)) == 0, float("-inf"))
soft = F.softmax(S, dim=-1) @ x                              # and the same thing again

loop vs matmul   max |diff| = 5.960464477539063e-08
loop vs softmax  max |diff| = 5.960464477539063e-08

the averaging matrix A (rows sum to 1, upper triangle is zero):
  1.000 0.000 0.000 0.000 0.000 0.000
  0.500 0.500 0.000 0.000 0.000 0.000
  0.333 0.333 0.333 0.000 0.000 0.000
  0.250 0.250 0.250 0.250 0.000 0.000
  0.200 0.200 0.200 0.200 0.200 0.000
  0.167 0.167 0.167 0.167 0.167 0.167

Τρία ονοματισμένα συστατικά ενός transformer βρίσκονται τώρα στην οθόνη. Το τρίγωνο είναι το causal mask, επιβεβλημένο από τον στόχο: αν η θέση $t$ μπορούσε να δει τη θέση $t{+}1$, η απάντηση θα ήταν στην είσοδο — η διαρροή που το Κεφάλαιο 6 σας είπε να ελέγχετε, μόνο που τώρα είναι μέσα στην αρχιτεκτονική. Το softmax είναι ο τρόπος υλοποίησης της μάσκας: θέτοντας τις απαγορευμένες εγγραφές σε $-\infty$, τις στέλνετε ακριβώς στο μηδέν και κανονικοποιείτε ό,τι απομένει, άρα masking και κανονικοποίηση είναι μία πράξη. (Χρησιμοποιήστε $-\infty$, όχι -1e9: είναι η τιμή που σημαίνει το masking, επιβιώνει σε cast σε float16 ως $-\infty$, και σας γλιτώνει από το να αποφασίσετε αν η σταθερά που διαλέξατε είναι αρκετά μεγάλη για το εύρος στο οποίο τυχαίνει να βρίσκεστε — δηλαδή το κουτί floating-point του Κεφαλαίου 2 να κάνει μια ερώτηση που δεν χρειάζεται να απαντήσετε.) Και τα scores είναι η ελεύθερη παράμετρος. Ο ομοιόμορφος μέσος όρος είναι αυτό που παίρνετε όταν κάθε επιτρεπτό score είναι ο ίδιος αριθμός· βάλτε οποιουσδήποτε αριθμούς εκεί και το softmax τους μετατρέπει σε έγκυρα βάρη.

Το υπόλοιπο αυτού του κεφαλαίου είναι μία ερώτηση: από πού έρχονται αυτοί οι αριθμοί;

Δεν μπορούν να είναι απλές παράμετροι. Ένας learned πίνακας $T \times T$ θα ήταν ίδιος για κάθε πρόταση — θα μπορούσε να κωδικοποιεί «κοίτα τέσσερα tokens πίσω», αλλά ποτέ «κοίτα το ουσιαστικό στο οποίο αναφέρεται αυτή η αντωνυμία». Το βάρος που συνδέει τη θέση $t$ με τη θέση $i$ πρέπει να εξαρτάται από το τι υπάρχει και στις δύο θέσεις, γιατί η συνάφεια είναι σχέση, όχι ιδιότητα: η λέξη it δεν είναι εγγενώς σχετική, είναι σχετική με κάτι.

Η φθηνότερη συνάρτηση δύο vectors που επιστρέφει έναν αριθμό είναι το dot product του Κεφαλαίου 1. Βαθμολογήστε τη θέση $i$ για τη θέση $t$ ως $\mathbf{x}_t \cdot \mathbf{x}_i$ και ο μηχανισμός δουλεύει — άσχημα, με δύο τρόπους που επιβάλλουν όλα τα υπόλοιπα. Το dot product ενός vector με τον εαυτό του είναι το τετράγωνο του norm του, άρα κάθε token θα έκανε attend κυρίως στον εαυτό του. Και η σχέση θα ήταν συμμετρική: αν το it κάνει έντονα attend στο animal, τότε το animal κάνει έντονα attend στο it, κάτι που είναι ψευδές για τη γλώσσα, όπου ένα επίθετο χρειάζεται το ουσιαστικό του πολύ περισσότερο από όσο το ουσιαστικό χρειάζεται το επίθετο.

Δώστε λοιπόν σε κάθε token δύο ρόλους, ως δύο learned linear maps του: τι αναζητά αυτή η θέση, $\mathbf{q}_t = W_q\mathbf{x}_t$, το query· και τι προσφέρει ώστε να βρεθεί, $\mathbf{k}_i = W_k\mathbf{x}_i$, το key. Βαθμολογήστε $\mathbf{q}_t \cdot \mathbf{k}_i$ και η συμμετρία χάθηκε, γιατί $W_q \neq W_k$: ένα token μπορεί να διαφημίζει ένα πράγμα και να ψάχνει άλλο.

Ένα πράγμα παραμένει λάθος. Το σταθμισμένο άθροισμα γινόταν πάνω στα ίδια τα $\mathbf{x}_i$, κάτι που αναγκάζει αυτό που αντιγράφεται να είναι το ίδιο με αυτό που ταιριάζει. Το matching θέλει τα χαρακτηριστικά που ταυτοποιούν ένα token· η αντιγραφή θέλει τα χαρακτηριστικά που είναι χρήσιμα downstream. Άρα μαθαίνουμε έναν τρίτο χάρτη, $\mathbf{v}_i = W_v\mathbf{x}_i$, το value, και αθροίζουμε αυτά.

Ο τύπος είναι πλέον λογιστική:

με $M$ το causal mask, μηδέν πάνω και κάτω από τη διαγώνιο και $-\infty$ από πάνω. Σε κώδικα είναι τριάντα γραμμές, από τις οποίες οι είκοσι είναι σχήματα:

class Head(nn.Module):
    """One head of causal self-attention."""

    def __init__(self, d_model, d_head, block):
        super().__init__()
        self.q = nn.Linear(d_model, d_head, bias=False)      
        self.k = nn.Linear(d_model, d_head, bias=False)      
        self.v = nn.Linear(d_model, d_head, bias=False)      
        self.d_head = d_head
        self.register_buffer("mask", torch.tril(torch.ones(block, block)).bool())

    def forward(self, x):
        T = x.shape[1]
        q, k, v = self.q(x), self.k(x), self.v(x)
        s = q @ k.transpose(-2, -1) / math.sqrt(self.d_head)          
        s = s.masked_fill(~self.mask[:T, :T], float("-inf"))          
        w = F.softmax(s, dim=-1)                                      
        return w @ v                                                  

Score, mask, κανονικοποίηση, ανάμειξη. Όλα τα άλλα είναι projection.

Σχεδόν κάθε εξήγηση του $\sqrt{d_k}$ λέει «για να μην κορεστεί το softmax», που είναι αλήθεια και δεν εξηγεί τίποτα. Το επιχείρημα είναι δύο γραμμές της διακύμανσης από το Κεφάλαιο 2. Αν οι εγγραφές των $\mathbf{q}$ και $\mathbf{k}$ είναι ανεξάρτητες με μέσο μηδέν και διακύμανση ένα, κάθε γινόμενο $q_j k_j$ έχει διακύμανση ένα, και οι διακυμάνσεις ανεξάρτητων πραγμάτων προστίθενται:

Άρα τα scores έχουν τυπική απόκλιση $\sqrt{d_k}$. Μετρημένο πάνω σε είκοσι χιλιάδες τυχαία ζεύγη:

     d     Var(q.k)         std   sqrt(d)
     4        3.975       1.994     2.000
    16       16.071       4.009     4.000
    64       64.249       8.016     8.000
   256      253.065      15.908    16.000
  1024     1015.562      31.868    32.000

Γιατί έχει σημασία: το softmax είναι ευαίσθητο στην κλίμακα με τρόπο που ένα linear layer δεν είναι. Αν διπλασιάσετε την είσοδο ενός linear layer, διπλασιάζετε την έξοδό του· αν πολλαπλασιάσετε τα scores επί δέκα πριν από ένα softmax, μετατρέπετε ένα μαλακό μείγμα σε σκληρή επιλογή. Μία γραμμή 64 scores, με και χωρίς τη διαίρεση:

«Effective tokens» είναι το εκθετικό του entropy: σε πόσες θέσεις κάνει πραγματικά μέσο όρο η γραμμή. Χωρίς διαίρεση, στο $d_k = 256$, ένα πρόσφατα αρχικοποιημένο head κάνει attend σε ακριβώς ένα token από τα 64, επιλεγμένο από τίποτα πέρα από την τυχαία κλήρωση.

Αυτό είναι κακό προς τα εμπρός και χειρότερο προς τα πίσω, σε σχήμα που το Κεφάλαιο 5 ήδη μέτρησε σε ένα $\tanh$. Ένα softmax δεσμευμένο σε μία εγγραφή έχει σχεδόν μηδενική παράγωγο: η διαγώνιος του Jacobian του είναι $w_i(1-w_i)$, μηδέν και στα δύο άκρα. Πάνω σε δύο χιλιάδες τυχαίες γραμμές:

Στο $d_k = 1024$, επτά γραμμές στις δέκα είναι παγωμένες πριν αρχίσει η εκπαίδευση, και ένα head που ξεκινά παγωμένο δεν μπορεί να μάθει πού να κοιτάζει. Με διαίρεση, η ποσότητα είναι επίπεδη στο 0.96 σε κάθε πλάτος και τίποτα δεν κορέννυται.

Τώρα το μέρος που κανείς δεν δημοσιεύει: αλλάζει το τελικό perplexity; Διαγράψτε τη διαίρεση και εκπαιδεύστε, σε τέσσερα πλάτη head:

Οι δύο πρώτες γραμμές προέρχονται από το budget 3000 βημάτων παραπάνω· οι τρεις τελευταίες είναι μια συντομότερη εκτέλεση — 1500 βήματα, batch 32, ένα head, χωρίς κανονικοποίηση πριν από τα projections — με τις δύο παραλλαγές σε πανομοιότυπες ρυθμίσεις.

Στο $d_k = 32$ η διαίρεση δεν αξίζει τίποτα και η εκτέλεση χωρίς αυτήν είναι ελάχιστα μπροστά. Αυτό δεν είναι άδεια να την πετάξετε, γιατί στο 256 αξίζει 18 μονάδες perplexity και στο 1024 αξίζει 17. Ο μηχανισμός φαίνεται στα ίδια τα scores:

Το head χωρίς διαίρεση δεν ανακάμπτει. Ξεφεύγει: η τυπική απόκλιση των scores του πηγαίνει από 21 στην αρχικοποίηση σε 5147, το attention entropy πέφτει στο μηδέν, και το 99.9 % των γραμμών βάζει πάνω από 0.99 του βάρους του σε ένα μόνο token. Μόλις ένα head γίνει σκληρός επιλογέας, το gradient του είναι σχεδόν μηδέν και τίποτα δεν το τραβά πίσω, άρα η κατάρρευση είναι σταθερή. Το διαιρεμένο head κάθεται σε τυπική απόκλιση score 3.44 μετά την ίδια εκπαίδευση, που είναι ένα μαλακό μείγμα που μπορεί ακόμη να αλλάξει.

Οι Vaswani et al. λένε ακριβώς αυτό και τίποτα περισσότερο — υποψιάζονται ότι τα γινόμενα «μεγαλώνουν σε μέγεθος για μεγάλες τιμές του $d_k$» και διαιρούν.⁵ Η λέξη μεγάλες σηκώνει βάρος, και οι πίνακες λένε πού αρχίζει το μεγάλο: τίποτα στο 32, τα πάντα μέχρι το 256.

Ένα head είναι μία γραμμή softmax ανά θέση, άρα κρατά μία απάντηση στο «τι είναι σχετικό εδώ». Η πρόβλεψη της λέξης μετά το the στο the animal that crossed the wet street χρειάζεται ταυτόχρονα το συντακτικό slot, το υποκείμενο και το προηγούμενο token, και μία κατανομή πιθανότητας δεν μπορεί να είναι συγκεντρωμένη σε τρία σημεία. Άρα τρέξτε πολλά heads παράλληλα, το καθένα με πλάτος $d_{\text{model}}/h$, συνενώστε, και αναμείξτε με έναν ακόμη πίνακα $W_o$: έχετε διαμερίσει το πλάτος, δεν το έχετε προσθέσει.

Το attention κάνει επίσης ακριβώς ένα πράγμα — μετακινεί πληροφορία μεταξύ θέσεων. Κάθε πράξη στον παραπάνω κώδικα είναι γραμμική κατά τον άξονα των χαρακτηριστικών, και το Κεφάλαιο 5 απέδειξε τι είναι μια στοίβα γραμμικών χαρτών. Άρα κάθε block κουβαλά επίσης ένα μικρό MLP που εφαρμόζεται σε κάθε θέση ανεξάρτητα, επεκτείνοντας το πλάτος επί τέσσερα και επιστρέφοντας, με GELU στη μέση. Η διαίρεση εργασίας αξίζει να απομνημονευτεί: το attention αναμειγνύει μεταξύ θέσεων, το feed-forward network υπολογίζει μέσα σε μια θέση.

Η πλήρης σκάλα, όπου κάθε γραμμή προσθέτει ένα κομμάτι στη γραμμή από πάνω της:

Τα learned βάρη κερδίζουν τα ομοιόμορφα κατά 14 μονάδες perplexity, που είναι ολόκληρο το επιχείρημα αυτού του κεφαλαίου σε μία γραμμή. Τα τέσσερα heads αγοράζουν άλλες 3 για 16.512 επιπλέον παραμέτρους. Και το ίδιο head αξίζει 9 μονάδες περισσότερο όταν προστίθεται παρά όταν αντικαθιστά: το attention φέρνει πληροφορία μέσα, δεν αποφασίζει τι είναι μια θέση.

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

Τα δύο τρίτα κάθε transformer block είναι το feed-forward network, σε κάθε κλίμακα, επειδή το attention έχει τέσσερις πίνακες $d \times d$ και το MLP έχει το ισοδύναμο οκτώ. Ό,τι κι αν ξέρει ένα μοντέλο, οι περισσότερες παράμετροι που το κρατούν βρίσκονται στο ανά-θέση MLP.

Το LayerNorm χτίστηκε και μετρήθηκε στο Κεφάλαιο 6, και αυτό το κεφάλαιο το χρησιμοποιεί όπως αφέθηκε εκεί· οι residual connections ονομάστηκαν και αφαιρέθηκαν σε ablation εκεί, και χτίζονται εδώ. Οι γραμμές «προστίθεται, δεν αντικαθιστά» παραπάνω είναι residual connections, αξίας 188 μονάδων perplexity για τον μέσο όρο και 9 για ένα head. Το LayerNorm⁷ κανονικοποιεί κάθε παράδειγμα κατά μήκος των χαρακτηριστικών του, και το Κεφάλαιο 6 έδωσε τους λόγους που αυτό, και όχι το BatchNorm, επέζησε εδώ — καμία εξάρτηση από το batch, κανένα running statistic, ταυτόσημο στην εκπαίδευση και στην inference, αδιάφορο στο μήκος ακολουθίας — καθένας από τους οποίους γίνεται απαίτηση όταν παράγετε ένα token τη φορά για έναν χρήστη, εκεί όπου καταλήγει το Κεφάλαιο 13. Κοστίζει 768 παραμέτρους και αγοράζει 1,8 μονάδες perplexity.

class Block(nn.Module):
    def forward(self, x):
        x = x + self.att(self.ln1(x))     
        x = x + self.ff(self.ln2(x))      
        return x

Κοιτάξτε πού κάθεται η κανονικοποίηση: στην είσοδο κάθε sub-layer, με το residual path από είσοδο σε έξοδο να μην κανονικοποιείται ποτέ. Αυτό είναι pre-norm. Το paper του 2017 κάνει το αντίθετο, x = LayerNorm(x + Att(x)) — post-norm, που βάζει ένα LayerNorm πάνω στο ίδιο το residual path.

Οι Xiong et al. εξήγησαν τη διαφορά μέσω του gradient στην αρχικοποίηση, που σε ένα post-norm δίκτυο είναι άσχημα κλιμακωμένο με το βάθος — ο λόγος που το αρχικό transformer χρειαζόταν warmup του learning rate για να εκπαιδευτεί καθόλου.⁸ Δώδεκα blocks, 1000 βήματα, learning rate $3 \times 10^{-3}$:

gradient norm per block at initialisation, before any step
  pre-norm    block 1 0.0498 ... block 12 0.0657   ratio last/first  1.32
  post-norm   block 1 0.0977 ... block 12 0.1613   ratio last/first  1.65

  pre-norm,  no warmup          perplexity   37.82
  pre-norm,  200-step warmup    perplexity   37.62
  post-norm, no warmup          perplexity  308.05
  post-norm, 200-step warmup    perplexity   37.88

Το post-norm χωρίς warmup είναι οκτώ φορές χειρότερο, και το post-norm με warmup ταιριάζει ακριβώς με το pre-norm. Το warmup δεν είναι μια γενικά καλή πρακτική εδώ· είναι ένα patch για μια συγκεκριμένη διάταξη της κανονικοποίησης, και μετακινώντας το LayerNorm αφαιρείτε την ανάγκη για αυτό. Γι’ αυτό ουσιαστικά κάθε μοντέλο από το 2019 είναι pre-norm, και γι’ αυτό το διάγραμμα του 2017 πρέπει να διαβάζεται ως ιστορία και όχι ως προδιαγραφή.

Διαγράψτε τα position embeddings και το μοντέλο ακόμα εκπαιδεύεται· απλώς δεν μπορεί να πει πού βρίσκεται οτιδήποτε, και αυτό είναι συμμετρία αντί για αποτυχία εκπαίδευσης. Τίποτα στο attention score δεν αναφέρει τα ίδια τα $t$ ή $i$, άρα αν μεταθέσετε την είσοδο μετατίθεται και η έξοδος: το self-attention είναι permutation-equivariant. Είναι η τυφλότητα του μέσου όρου στη σειρά με καλύτερη μεταμφίεση — το causal mask αποκαθιστά λίγη σειρά, αφού κάθε θέση βλέπει διαφορετικό πρόθεμα, αλλά μέσα σε ένα πρόθεμα όλες οι διατάξεις μοιάζουν ίδιες.

Τέσσερις τρόποι εισαγωγής θέσης, εκπαιδευμένοι σε windows 64 tokens και αξιολογημένοι στα 64, 128 και 256 — πέρα από κάθε μήκος που είδαν:

Τα learned absolute embeddings — ένα vector ανά θέση, προστιθέμενο στο token — κερδίζουν στο εκπαιδευμένο μήκος και μετά πέφτουν από γκρεμό, επειδή η θέση 100 δεν ήταν ποτέ σε batch και το embedding της είναι ακόμη το τυχαίο vector με το οποίο ξεκίνησε. Τα sinusoids, η αρχική επιλογή, υπολογίζονται αντί να μαθαίνονται, από ημίτονα και συνημίτονα σε γεωμετρικά κατανεμημένες συχνότητες· το paper του 2017 ήλπιζε ότι αυτό θα έκανε extrapolate, και ο πίνακας λέει ότι δεν το κάνει — η συνάρτηση είναι ορισμένη στη θέση 200, αλλά το μοντέλο δεν έμαθε ποτέ να τη διαβάζει εκεί. Το RoPE⁹ δεν προσθέτει τίποτα και αντίθετα περιστρέφει query και key κατά γωνία ανάλογη της θέσης, σε δισδιάστατες φέτες· αφού η ίση περιστροφή και των δύο πλευρών ενός dot product το αφήνει αμετάβλητο, το score καταλήγει να εξαρτάται μόνο από το $t - i$, άρα η θέση γίνεται σχετική δωρεάν και δεν υπάρχει πίνακας που να εξαντλείται. Υποβαθμίζεται, αλλά υποβαθμίζεται. Το ALiBi¹⁰ είναι το απλούστερο και το πιο παράξενο αποτέλεσμα εδώ: μια γραμμική ποινή στο score ανάλογη της απόστασης, με διαφορετική κλίση ανά head. Το perplexity του βελτιώνεται καθώς το window μεγαλώνει πέρα από το μήκος εκπαίδευσης, από 44.95 σε 42.49, επειδή η ποινή είναι ορισμένη σε οποιαδήποτε απόσταση και κάθε head συνεχίζει να κάνει αυτό που εκπαιδεύτηκε να κάνει.

Το μάθημα επιβιώνει πέρα από τον πίνακα: μια αρχιτεκτονική που δεν μπορεί να αναπαραστήσει κάτι είναι διαφορετικό πρόβλημα από μία που απλώς δεν έμαθε ποτέ εκείνο το εύρος, και το δεύτερο είναι αυτό που δαγκώνει. Είναι επίσης ο μηχανισμός πίσω από κάθε ανακοίνωση «επεκτείναμε το context στα 128K» — αυτά είναι σχεδόν πάντα επανακλιμακώσεις ενός rotary encoding, και είναι ο λόγος που το Κεφάλαιο 16 λέει ότι το όριο του context μετακινείται αντί να εξαφανίζεται.

Το dropout κληρονομείται με τον ίδιο τρόπο: εμφανίζεται στα attention βάρη μετά το softmax, στην έξοδο κάθε sub-layer πριν από την residual πρόσθεση, και στο άθροισμα embedding, κάνοντας ακριβώς ό,τι περιέγραψε το Κεφάλαιο 6. Σε μεγάλες pretraining εκτελέσεις συχνά τίθεται στο μηδέν, επειδή ένα μοντέλο που βλέπει κάθε token μία φορά δεν είναι σε θέση να κάνει overfit.

Δύο tensors στο layer έχουν σχήμα $n \times n$, όπου $n$ είναι ο αριθμός των tokens: τα scores και τα βάρη μετά το softmax. Όλα τα άλλα — κάθε projection, όλο το MLP — είναι γραμμικά ως προς $n$.

Ένα attention layer, πλάτους 512, 8 heads, batch ενός, float32, σε laptop GPU. Διαβάστε τις δύο στήλες millisecond μόνο για τους λόγους τους: είναι wall clock σε κάρτα laptop 8 GB που throttles από 1.785 MHz σε κάτω από 300 MHz όταν ζεσταίνεται, άρα μια κρύα εκτέλεση του ίδιου κώδικα επιστρέφει επτά έως δέκα φορές γρηγορότερα και μια απασχολημένη ακόμη πιο αργά. Οι στήλες megabyte είναι μετρήσεις bytes του allocator και δεν μετακινούνται.

  tokens   ms total    ms x4   ms projections   attn matrix MB    peak MB    MB x4
     128      2.246        -            1.324              0.5       14.6        -
     256      2.855     1.27            2.113              2.0       19.2     1.31
     512      5.761     2.02            3.105              8.0       34.4     1.79
    1024     16.414     2.85            4.008             32.0       89.1     2.59
    2048     51.573     3.14            9.989            128.0      296.1     3.32
    4096    225.432     4.37           20.176            512.0     1100.1     3.72
    8192    832.838     3.69           40.106           2048.0     4300.1     3.91
   16384   OUT OF MEMORY                                 8192.0

fitted exponent (log-log slope, last four rows):  time ~ n^1.91   memory ~ n^1.87

Οι στήλες x4 είναι ο λόγος προς τη γραμμή από πάνω, και ο διπλασιασμός του $n$ συγκλίνει ακριβώς στο 4 τόσο για τον χρόνο όσο και για τη μνήμη — 3.91 στο τελευταίο βήμα έναντι θεωρητικού 4. Η στήλη projections είναι ο έλεγχος: 4.0 ms στα 1024 tokens σε 40.1 ms στα 8192, συντελεστής δέκα για συντελεστή οκτώ. Γραμμικό, όπως διαφημίστηκε.

Μετά η τελευταία γραμμή. Ένα attention layer, μία ακολουθία, χωρίς μοντέλο γύρω του, ξεμένει από μνήμη σε GPU 8 GB στα 16.384 tokens — μόνο ο πίνακας scores θα ήταν 8 GB, όντας 8 heads επί 16.384 επί 16.384 επί 4 bytes. Όχι το μοντέλο· ένα ενδιάμεσο tensor σε ένα layer.

Αυτό είναι το φυσικό γεγονός κάτω από τρία επόμενα κεφάλαια. Είναι ο λόγος που ένα context window έχει όριο εξαρχής, κάτι που το Κεφάλαιο 16 μετατρέπει σε τιμή. Είναι ο λόγος που υπάρχει το FlashAttention, υπολογίζοντας το ίδιο αποτέλεσμα σε tiles χωρίς ποτέ να αποθηκεύει τον πίνακα — βελτιστοποίηση μνήμης πριν γίνει βελτιστοποίηση ταχύτητας.¹¹ Και είναι η αριθμητική πίσω από την τιμή ενός μεγάλου prompt, που το Κεφάλαιο 24 πληρώνει σε ένα agent loop — ξεχωριστό θέμα από το άλλο εύρημα εκείνου του κεφαλαίου, ότι ένα μοντέλο επίσης χρησιμοποιεί χειρότερα ένα μακρύ context, κάτι που μετρά και αρνείται να κατηγορήσει αυτόν τον τύπο.

Το paper του 2017 περιγράφει ένα encoder-decoder: μία στοίβα που διαβάζει την πηγή με unmasked attention, μια δεύτερη που παράγει τον στόχο causal, και ένα τρίτο είδος attention στη μέση όπου τα queries του decoder συναντούν τα keys του encoder. Αυτό είναι σωστό για τη μετάφραση, όπου είσοδος και έξοδος είναι δύο ακολουθίες.

Αυτό που κέρδισε ήταν το μισό decoder-only — μία στοίβα, causal παντού, είσοδος και έξοδος στην ίδια ακολουθία — και ο λόγος δεν είναι η κομψότητα. Το «προέβλεψε το επόμενο token» τρέχει σε οποιοδήποτε κείμενο, άρα το σύνολο εκπαίδευσης είναι το internet αντί για ένα parallel corpus, και όλα γίνονται εκείνη η μία εργασία: μια μετάφραση είναι ένα έγγραφο που περιέχει πηγή και μετά στόχο, μια ερώτηση και η απάντησή της είναι ένα έγγραφο, μια συζήτηση με ένα tool call στη μέση είναι ένα έγγραφο. Το Κεφάλαιο 11 αφορά το πώς κατασκευάζεται το τελευταίο. Οι encoders δεν εξαφανίστηκαν — ένας encoder βλέπει όλη την είσοδο μονομιάς, που είναι αυτό που θέλετε όταν η δουλειά είναι να αναπαραστήσει ένα κείμενο αντί να το συνεχίσει, και γι’ αυτό τα retrieval embeddings του Κεφαλαίου 19 έρχονται από encoders και όχι από το μοντέλο που κάνει τη συνομιλία.

Με το block ορισμένο, το μέγεθος μοντέλου είναι αριθμητική. Ανά block, με πλάτος $d$ και τετραπλάσια επέκταση: $4d^2 + 4d$ για $W_q, W_k, W_v, W_o$ με biases και στα τέσσερα, όπως τα έχει το GPT-2 — ο παραπάνω πίνακας αφήνει το bias εκτός σε τρία από αυτά, εξ ου και 2.304 λιγότερα ανά block στο $d = 768$· $8d^2 + 5d$ για το MLP· $4d$ για δύο LayerNorms — $12d^2 + 13d$, συν έναν token πίνακα $V \times d$ και, για absolute positions, $n_{\text{ctx}} \times d$. Για το σχήμα του GPT-2 small — $d = 768$, 12 blocks, λεξιλόγιο 50.257, context 1024, το output layer να μοιράζεται τα embedding βάρη:

  token embeddings     50,257 x 768 = 38,597,376
  position embeddings   1,024 x 768 =    786,432
  one block                             7,087,872
  12 blocks                            85,054,464
  final LayerNorm         2 x 768 =        1,536
  total (weights tied)                124,439,808

Που είναι το δημοσιευμένο μέγεθος εκείνου του μοντέλου. Ο τύπος δεν είναι προσέγγιση· είναι το μοντέλο. Σημειώστε επίσης ότι σχεδόν το ένα τρίτο ενός μικρού μοντέλου είναι ο embedding πίνακας, γι’ αυτό το μέγεθος λεξιλογίου είναι αρχιτεκτονική απόφαση και όχι απόφαση preprocessing — το trade-off που έστησε το Κεφάλαιο 7.

Το perplexity είναι ένας αριθμός για ένα corpus. Το τι κάνει ένα head είναι διαφορετική ερώτηση, και ένα μοντέλο εκπαιδευμένο σε ένα megabyte Shakespeare είναι λάθος όργανο για αυτήν: το ειλικρινές πράγμα που μπορεί κανείς να πει για τον attention map ενός μοντέλου 500.000 παραμέτρων είναι ότι κυρίως δεν είναι ερμηνεύσιμος. Άρα: μια γλώσσα όπου η ερώτηση έχει σωστή απάντηση.

Η κλασική απεικόνιση είναι the animal did not cross the street because it was too tired, όπου το it είναι το animal, σε αντίθεση με το …because it was too wet, όπου μία λέξη μετακινεί το αναφερόμενο στο street. Αυτά είναι Winograd schemas¹⁴ — ζεύγη προτάσεων ίδια εκτός από μία λέξη, όπου εκείνη η λέξη αποφασίζει σε τι αναφέρεται μια αντωνυμία.

Είναι επίσης λύσιμα με κλεψιά, που είναι το μέρος που παραλείπουν τα tutorials. Αν οι δύο υποψήφιοι είναι ένα ζώο και ένα μέρος, τα tired και wet ταυτοποιούν το αναφερόμενο μέσω κατηγορίας, και ένα μοντέλο που ξέρει μόνο ποιες λέξεις είναι παρούσες το πετυχαίνει χωρίς να ξέρει τίποτα για τη σειρά. Μετρημένο σε αυτήν την έκδοση της εργασίας, με held-out ζεύγη animal/place:

uniform causal average           held-out referent accuracy 100.0 %
one transformer block            held-out referent accuracy  91.7 %

Το bag of words κερδίζει το transformer. Οποιαδήποτε επίδειξη χτισμένη πάνω σε εκείνη την πρόταση δεν αποδεικνύει τίποτα για το attention.

Κλείστε λοιπόν την τρύπα: τραβήξτε και τους δύο υποψηφίους από μία δεξαμενή δεκαέξι ουσιαστικών, καθένα από τα οποία μπορεί να εμφανιστεί σε οποιοδήποτε slot, και χωρίστε τα επίθετα ανά ρόλο αντί για κατηγορία — τέσσερα που κάνουν το it αυτό που διασχίζει (tired, scared, slow, weak), τέσσερα που το κάνουν αυτό που διασχίζεται (wet, wide, busy, steep).

the {x} did not cross the {y} because it was too {adj} , so the {ref} waited .

Εκπαιδεύστε ως συνηθισμένο next-token predictor, βαθμολογήστε μία θέση — τη λέξη μετά το so the — και χτίστε το held-out set από ζεύγη ουσιαστικών των οποίων η αντίστροφη σειρά ήταν στην εκπαίδευση, ώστε οτιδήποτε ξέρει ποια δύο ουσιαστικά είναι παρόντα αλλά όχι ποιο ήρθε πρώτο να πρέπει να απαντήσει ανάποδα.

Η τύχη ανάμεσα στα δύο παρόντα ουσιαστικά είναι 50 %. Ο ομοιόμορφος μέσος όρος προσγειώνεται στο 27.9 % και απαντά με το λάθος ουσιαστικό του ζεύγους ακριβώς τις μισές φορές — η υπογραφή κάτι που ξέρει ποιες λέξεις υπάρχουν εκεί και τίποτα για τη σειρά τους, όπως προέβλεψε το shuffle test τρεις ενότητες πριν.

Τώρα ο χάρτης: το attention στη θέση που πρέπει να ονομάσει το αναφερόμενο, μέσος όρος πάνω στα τέσσερα heads κάθε block, για τις δύο προτάσεις που διαφέρουν κατά μία λέξη. Ένας ομοιόμορφος μέσος όρος θα έβαζε 0.067 σε καθένα από τα δεκαπέντε ορατά tokens.

the animal did not cross the street because it was too tired , so the animal waited .
  blk 1  the:0.00 animal:0.70 did:0.00 not:0.00 cross:0.00 the:0.00 street:0.06
         because:0.00 it:0.00 was:0.00 too:0.00 tired:0.00 ,:0.05 so:0.00 the:0.19
  blk 2  the:0.00 animal:0.00 did:0.00 not:0.00 cross:0.00 the:0.00 street:0.00
         because:0.00 it:0.00 was:0.00 too:0.00 tired:1.00 ,:0.00 so:0.00 the:0.00

the animal did not cross the street because it was too wet , so the street waited .
  blk 1  the:0.00 animal:0.70 did:0.00 not:0.00 cross:0.00 the:0.00 street:0.06
         because:0.00 it:0.00 was:0.00 too:0.00   wet:0.00 ,:0.05 so:0.00 the:0.19
  blk 2  the:0.00 animal:0.00 did:0.00 not:0.00 cross:0.03 the:0.00 street:0.49
         because:0.00 it:0.00 was:0.00 too:0.20   wet:0.03 ,:0.00 so:0.00 the:0.25

Το Block 1 είναι πανομοιότυπο και στις δύο προτάσεις — 0.70 στο πρώτο ουσιαστικό, όποιο κι αν είναι το επίθετο. Αυτό δεν είναι αποτυχία αλλά απόδειξη: στο πρώτο layer, το query σε μια θέση είναι συνάρτηση του δικού της token και index, και το the στη θέση 14 είναι το ίδιο token και στις δύο προτάσεις. Ένα head πρώτου layer δεν μπορεί να εξαρτηθεί από μια λέξη που δεν έχει ακόμη φέρει. Άρα το block 1 κάνει το μόνο χρήσιμο πράγμα που έχει διαθέσιμο και σέρνει το πρώτο ουσιαστικό προς τα εμπρός.

Το Block 2 είναι εκεί όπου οι προτάσεις χωρίζουν, και η ίδια γραμμή σε όλα τα οκτώ επίθετα δείχνει τον κανόνα που βρήκε το μοντέλο:

Για ένα crosser-adjective, το δεύτερο block ξοδεύει όλο το βάρος του στο επίθετο, επειδή η απάντηση βρίσκεται ήδη στο residual stream — το block 1 την έβαλε εκεί — και το μόνο που χρειάζεται είναι επιβεβαίωση. Για ένα crossed-adjective, πηγαίνει και φέρνει το άλλο ουσιαστικό αντ’ αυτού. Αυτό είναι ένα two-hop circuit: ένα head μετακινεί έναν υποψήφιο προς τα εμπρός, ένα head σε μεταγενέστερο layer διαβάζει ένα token που αποφασίζει αν θα τον κρατήσει. Η σύνθεση μεταξύ layers είναι ο μηχανισμός, και γι’ αυτό ένα block έφτασε 92.7 % και δύο έφτασαν 100 %.

Είναι επίσης το σχήμα του καλύτερα τεκμηριωμένου circuit σε πραγματικά μοντέλα. Induction heads — ένα previous-token head που τροφοδοτεί ένα head στο επόμενο layer που συμπληρώνει το μοτίβο [A][B] … [A] → [B] — είναι αυτό που η δουλειά ερμηνευσιμότητας της Anthropic εντοπίζει πίσω από μεγάλο μέρος του in-context learning, και σχηματίζονται σε αναγνωρίσιμη στιγμή κατά το pretraining. Αυτό το κεφάλαιο δεν επιχειρεί εκείνη την ανάλυση: την αναθέτει, με τα δύο papers στις αναφορές, επειδή το να διαβάζεις circuits από ένα πραγματικό μοντέλο είναι ερευνητικό πεδίο και όχι ενότητα.

Τέλος, η υλοποίηση. Οι τριάντα γραμμές παραπάνω, με τα βάρη τους αντιγραμμένα από το ίδιο το PyTorch:

ours vs nn.MultiheadAttention           max |diff| = 1.7881393432617188e-07
ours vs F.scaled_dot_product_attention  max |diff| = 1.7881393432617188e-07

$1.8 \times 10^{-7}$ σε εξόδους των οποίων το μέσο μέγεθος είναι 0.159: η ίδια αριθμητική σε διαφορετική σειρά, με ακρίβεια float32.

Έχετε την αρχιτεκτονική πάνω στην οποία χτίζεται κάθε μοντέλο στο υπόλοιπο αυτού του μαθήματος, και είναι μικρότερη από τη φήμη της: ένας σταθμισμένος μέσος όρος του οποίου τα βάρη μαθαίνονται, ένα ανά-θέση MLP που κρατά τα δύο τρίτα των παραμέτρων, δύο κανονικοποιήσεις και δύο προσθέσεις, στοιβαγμένα.

Αυτό που δεν έχετε είναι ένα μοντέλο που ξέρει οτιδήποτε, και το stacking δεν θα το διορθώσει από μόνο του. Δύο blocks σε αυτό το corpus φτάνουν training perplexity 14.49 και validation perplexity 40.57, έναντι 18.77 και 38.07 για ένα block — περισσότερη χωρητικότητα, καλύτερο σε όσα έχει δει, χειρότερο σε όσα δεν έχει δει, που είναι ο πίνακας του Κεφαλαίου 6 με ένα transformer μέσα. Η απόσταση ανάμεσα σε αυτό το μοντέλο και σε εκείνα με τα οποία μιλούν τα Κεφάλαια 14 έως 30 δεν είναι αρχιτεκτονική. Είναι το ίδιο block, επαναλαμβανόμενο περισσότερες φορές, πάνω σε ασύγκριτα περισσότερο κείμενο.

Αυτό το κάνει πρόβλημα λογιστικής, και η λογιστική είναι πιο παράξενη από όσο φαίνεται. Πόσο κείμενο, και από πού το βρίσκει κανείς; Πόση αριθμητική, και πώς την εκτιμάτε πριν ξοδευτούν τα χρήματα; Με δεδομένο ένα σταθερό budget, είναι καλύτερο να κάνετε το μοντέλο μεγαλύτερο ή να του δείξετε περισσότερα δεδομένα — και υπάρχει σωστή απάντηση, ή μόνο μόδα; Το Κεφάλαιο 10 απαντά και στα τρία με μέτρηση, και βάζει τιμή στη φθηνότερη χρήσιμη μορφή της ερώτησης: τι κοστίζει, σήμερα, να εκπαιδεύσετε ένα μοντέλο σαν το GPT-2 από το μηδέν;

Τρεις εξηγήσεις αυτού του υλικού είναι καλύτερες από αυτήν στο πράγμα για το οποίο είναι φτιαγμένες, και αυτό το κεφάλαιο είναι γραμμένο για να διαβάζεται μαζί τους. Το The Illustrated Transformer του Jay Alammar είναι η καλύτερη εικόνα της ροής δεδομένων που σχεδιάστηκε ποτέ. Το The Annotated Transformer του Harvard NLP είναι το paper του 2017 με εκτελέσιμο κώδικα παρεμβαλλόμενο γραμμή προς γραμμή. Το Let's build GPT: from scratch, in code, spelled out του Andrej Karpathy χτίζει το ίδιο μοντέλο live σε δύο ώρες, και η σκάλα ablations παραπάνω είναι η ίδια ραχοκοκαλιά μετρημένη σε διαφορετικό corpus. Για το ερώτημα ερμηνευσιμότητας που αυτό το κεφάλαιο μόνο αγγίζει, οι πρωτογενείς πηγές είναι οι Elhage et al., A Mathematical Framework for Transformer Circuits (2021) και Olsson et al., In-context Learning and Induction Heads (2022), και οι δύο από την ομάδα ερμηνευσιμότητας της Anthropic.