Section 1 - Modeling

We started this course by analyzing a language model as a black box:

Then we looked at the training data of large language models (e.g., The Pile):

In this lecture, we will open up the onion all the way and talk about how large language models are built.

Today’s lecture will focus on two topics, tokenization and model architecture.

Tokenization: how a string is split into tokens.
Model architecture: We will discuss mostly the Transformer architecture, which is the modeling innovation that really enabled large language models.

Tokenization

Recall that a language model is a probability distribution over a sequence of tokens where each token comes from some vocabulary :

However, natural language doesn’t come as a sequence of tokens, but as just a string (concretely, sequence of Unicode characters):

A tokenizer converts any string into a sequence of tokens.

This is not necessarily the most glamorous part of language modeling, but plays a really important role in determining how well a model will work.

Split by spaces

The simplest solution is to do:

text.split(' ')

This doesn’t work for languages such as Chinese, where sentences are written without spaces between words:

我今天去了商店。 [gloss: I went to the store.]

Then there are languages like German that have long compound words (e.g., Abwasserbehandlungsanlange).
Even in English, there are hyphenated words (e.g., father-in-law) and contractions (e.g., don’t), which should get split up. For example, the Penn Treebank splits don’t into do and n’t, a linguistically-informed but not obvious choice.

Therefore, splitting by spaces by spaces to identify words is quite problematic.

What makes a good tokenization?

We don’t want too many tokens (extreme: characters or bytes), or else the sequence becomes difficult to model.
We don’t want too few tokens, or else there won’t be parameter sharing between words (e.g., should mother-in-law and father-in-law be completely different)? This is especially problematic for morphologically rich languages (e.g., Arabic, Turkish, etc.).
Each token should be a linguistically or statistically meaningful unit.

Byte pair encoding

Sennrich et al, 2015 applied the byte pair encoding (BPE) algorithm, originally developed for data compression, to produce one of the most commonly used tokenizers.

Learning the tokenizer. Intuition: start with each character as its own token and combine tokens that co-occur a lot.

Input: a training corpus (sequence of characters).
Initialize the vocabulary be the set of characters.
While we want to still grow :
- Find the pair of elements that co-occur the most number of times.
- Replace all occurrences of with a new symbol .
- Add to .

Example:

[t, h, e, ␣, c, a, r], [t, h, e, ␣, c, a, t], [t, h, e, ␣, r, a, t]
[th, e, ␣, c, a, r], [th, e, ␣, c, a, t], [th, e, ␣, r, a, t] (th occurs 3x)
[the, ␣, c, a, r], [the, ␣, c, a, t], [the, ␣, r, a, t] (the occurs 3x)
[the, ␣, ca, r], [the, ␣, ca, t], [the, ␣, r, a, t] (ca occurs 2x)

The output of learning is:

Updated vocabulary : [a, c, e, h, t, r, ca, th, the]
The merges that we made (important for applying the tokenizer):
- t, h th
- th, e the
- c, a ca

Applying the tokenizer. To tokenize a new string, apply the merges in the same order:

[t, h, e, ␣, o, x]
[th, e, ␣, o, x]
[the, ␣, o, x]

Unicode.

One problem is that (especially in the multilingual setting), there are a lot (144,697) of Unicode characters.
We certainly will not see all characters in the training data.
In order to reduce data sparsity even further, we can run BPE on bytes instead of Unicode characters (Wang et al. 2019).
Example in Chinese:

今天 [gloss: today] [x62, x11, 4e, ca]

Unigram model (SentencePiece)

Rather than just splitting by frequency, a more “principled” approach is to define an objective function that captures what a good tokenization looks like. We now describe the unigram model (Kudo 2018).

It was of the tokenizations supported in the SentencePiece tool (Kudo & Richardson, 2018), along with BPE.
It was used to train T5 and Gopher.

Given a sequence , a tokenization is a set of

Example:

Training data (string):
Tokenization ()
Likelihood: .

Algorithm:

Start with a “reasonably big” seed vocabulary .
Repeat:
- Given , optimize and using the EM algorithm.
- Compute for each token capturing how much the likelihood would be reduced if were removed from .
- Sort by loss and keep the top 80% tokens in .

Comparing tokenizers

GPT-2 and GPT-3 used BPE, vocabulary size of 50K
Jurassic used SentencePiece with vocabulary size of 256K

Impact:

Given the same string, Jurassic requires 28% fewer tokens than GPT-3, so it is 1.4x faster
Both Jurassic and GPT-3 use the same context size (2048), so one can feed in 39% more text into the prompt.

Examples of tokenizations for both GPT-3 and Jurassic (demo):

GPT-3: [Ab, raham, ␣Lincoln, ␣lived, ␣at, ␣the, ␣White, ␣House, .]
Jurassic: [Abraham␣Lincoln, ␣lived, ␣at␣the␣White␣House, .]

Models

Thus far, we have defined language models as a probability distribution over sequences of tokens , which as we saw was very elegant and powerful (via prompting, a language model can in principle do anything, as GPT-3 hints at). In practice, however, it can be more efficient for specialized tasks to avoid having to generatively model the entire sequence.

Contextual embeddings. As a prerequisite, the main key development is to associate a sequence of tokens with a corresponding sequence of contextual embeddings:

As the name suggests, the contextual embedding of a token depends on its context (surrounding words); for example, consider .
Notation: We will to be the embedding function (analogous to a feature map for sequences).
For a token sequence , produces contextual embeddings .

Types of language models

We will broaden our notion of language models to three types of models.

Encoder-only (BERT, RoBERTa, etc.). These language models produce contextual embeddings but cannot be used directly to generate text.

These contextual embeddings are generally used for classification tasks (sometimes boldly called natural language understanding tasks).

Example: sentiment classification

Example: natural language inference

Pro: contextual embedding for can depend bidirectionally on both the left context () and the right context ().
Con: cannot naturally generate completions.
Con: requires more ad-hoc training objectives (masked language modeling).

Decoder-only (GPT-2, GPT-3, etc.). These are our standard autoregressive language models, which given a prompt produces both contextual embeddings and a distribution over next tokens (and recursively, over the entire completion ).

Example: text autocomplete

Con: contextual embedding for can only depend unidirectionally on both the left context ().
Pro: can naturally generate completions.
Pro: simple training objective (maximum likelihood).

Encoder-decoder (BART, T5, etc.). These models in some ways can the best of both worlds: they can use bidirectional contextual embeddings for the input and can generate the output .

Example: table-to-text generation

Pro: contextual embedding for can depend bidirectionally on both the left context () and the right context ().
Pro: can naturally generate outputs.
Con: requires more ad-hoc training objectives.

Preliminaries

We now describe the innards of the embedding function :

We now introduce the model architectures for language model, with an emphasis on the ubiquitous Transformer architecture. Our exposition of the Transformer architecture will be based on these slides from CS221 on differentiable programming, and will depart a bit from the standard presentation.

The beauty of deep learning is being able to create building blocks, just like we build whole programs out of functions. So we want to be able to functions like the following to encapsulate the complexity:

This function will have parameters which we will include in the body but elide in the function signature for simplicity.

In what follows, we will define a library of building blocks until we get to the full Transformer.

Preliminaries

First, we have to convert sequences of tokens into sequences of vectors. does exactly this by looking up each token in an embedding matrix (a parameter that will be learned from data):

def :

Turns each token in the sequence into a vector.
Return .

These are exactly the (context-independent) word embeddings of yore. We define an abstract function that takes these context-independent embeddings and maps them into contextual embeddings.

def :

Process each element in the sequence with respect to other elements.
[abstract implementation (e.g., , , )]

The simplest type of sequence model is based on feedforward networks (Bengio et al., 2003) applied to a fixed length context, just as in an n-gram model:

def :

Process each element in the sequence by looking at the last elements..
For each :
- Compute .
Return .

Recurrent neural networks

The first “real” sequence model is a recurrent neural network (RNN), which is a family of models that include simple RNNs, LSTMs, and GRUs. The basic form of an RNN simply computes a sequence of hidden states recursively.

def :

Process the sequence left-to-right and recursively compute vectors .
For :
- Compute .
Return .

The actual module that does the hard work is the , which analogous to a finite state machine, takes the current state , a new observation , and returns the updated state:

def :

Updates the hidden state based on a new observation .
[abstract implementation (e.g., , , )]

There are three ways to implement the . The earliest RNN is a simple RNN Elman, 1990, which takes a linear combination of and and pushes it through an elementwise non-linear function (e.g., logistic or more the modern ReLU ).

def :

Updates the hidden state based on a new observation by simple linear transformation and non-linearity.
Return .

As defined RNNs only depend on the past, but we can them depend on the future two by running another RNN backwards. These models were used by ELMo and ULMFiT.

def :

Process the sequence both left-to-right and right-to-left.
Compute left-to-right: .
Compute right-to-left: .
Return .

Notes:

The simple RNN is difficult to train due to vanishing gradients.
The Long Short-Term Memory (LSTM) and Gated Recurrent Unit (GRU) (both of ) have been developed to address these.
Still, even though the embedding can depend arbitrarily far back (e.g., on ), it is unlikely to depend on it in a “crisp” way (see Khandelwal et al., 2018 for more discussion).
LSTMs in some sense were really what brought deep learning into full swing within NLP.

We will not discuss these models in the interest of time.

Transformers

Now, we will discuss Transformers (Vaswani et al. 2017), the sequence model that is really responsible for the takeoff of large language models; they are the building blocks of decoder-only (GPT-2, GPT-3), encoder-only (BERT, RoBERTa), and decoder-encoder (BART, T5) models.

There are great resources for learning about the Transformer:

Illustrated Transformer and Illustrated GPT-2: very nice visual description of the Transformer.
Annotated Transformer: Pytorch implementation of the Transformer.

You are highly encouraged to read these references. In this lecture, I will strive to take a middle path which emphasizes pseudocode functions and interfaces.

The crux of the Transformers are the attention mechanism, which was developed earlier for machine translation (Bahdananu et al. 2017).

One can think of attention as a “soft” lookup table, where we have a query that we want to match against each element in a sequence :

We can think of each as representing a key-value pair via linear transformations:

and forming the query via another linear transformation:

The key and the query can be compared to give a score:

These scores can be exponentiated and normalized to form a probability distribution over the token positions :

Then the final output is a weighted combination over the values:

We can write this all succinctly in matrix form:

def :

Process by comparing it to each .
Return .

We can think of there as being multiple aspects (e.g., syntax, semantics) that we would want to match on. To accommodate this, we can simultaneously have multiple attention heads and simply combine their outputs.

def

Process by comparing it to each with respect to aspects.
Return .

Self-attention layer. Now we will substitute each in for as the query argument to produce:

def :

Compare each element to each other element.
Return .

Feedforward layer. Self-attention allows all the tokens to “talk” to each other, whereas feedforward connections provide:

def :

Process each token independently.
For :
- Compute .
Return .

Improving trainability. We’re almost done. We could in principle just take the sequence model and iterate it 96 times to make GPT-3, but that network would be hard to optimize (for the same vanishing gradients problems that afflicted RNNs, now just along the depth direction). So we have to do two shenanigans to make sure that the network is trainable.

Residual connections. One trick from computer vision is residual connections (ResNet). Instead of applying some function :

we add a residual (skip) connection so that if ’s gradients vanish, gradients can still flow through :

Layer normalization. Another trick is layer normalization, which takes a takes a vector and makes sure its elements are too big:

def :

Make each not too big or small.

We first define an adapter function that takes a sequence model and makes it “robust”:

def :

Safely apply to .
Return .

Finally, we can define the Transformer block succinctly as follows:

def :

Process each element in context.
Return .

Positional embeddings. You might have noticed that as defined, the embedding of a token doesn’t depend on where it occurs in the sequence, so in both sentences would have the same embedding, which is not sensible.

To fix this, we add positional information into the embedding:

def :

Add in positional information.
Define positional embeddings:
- Even dimensions:
- Odd dimensions:
Return .

GPT-3. With all the pieces in place, we can now define roughly GPT-3 architecture in one line, just by stacking the Transformer block 96 times:

Shape of the architecture (how the 175 billion parameters are allocated):

Dimension of hidden state:
Dimension of the intermediate feed-forward layer:
Number of heads:
Context length:

These decisions are not necessarily optimal. Levine et al. 2020 provide some theoretical justification, showing that the GPT-3 is too deep, which motivated the training of a deeper but wider Jurassic architecture.

There are important but detailed differences between different versions of Transformers:

Layer normalization “post-norm” (original Transformers paper) versus pre-norm (GPT-2), which impacts training stability (Davis et al. 2021).
Dropout is applied throughout to prevent overfitting.
GPT-3 uses a sparse Transformer to reduce the number of parameters, interleaving it with dense layers.
Depending on the type of Transformer (encoder-only, decoder-only, encoder-decoder), different masking operations are used.
And of course there are many more details involved in the training of Transformer models which we will discuss next time.

What’s on your mind?

Create GitHub Issue

Send us feedback

Section 1 - Modeling

Tokenization

Split by spaces

Byte pair encoding

Unigram model (SentencePiece)

Comparing tokenizers

Models

Types of language models

Preliminaries

Preliminaries

Recurrent neural networks

Transformers

Further reading