Spreadsheets-are-all-you-need: Decoding the Decoder LLM without de code

[upbeat music] Hope you're all having a good conference. And I hope you're ready because if you came to this conference or the AI engineering field

without a machine learning degree, then this is gonna be your crash course in how machine learning models actually work under the hood.

Let's, let's bring up, uh, the slides. There we go. Thank you. Okay. So I'm Ishan, and I'm dressed in scrubs because today we're all going to be AI brain surgeons, and our patient will be none other than GPT-2, an early precursor to ChatGPT.

And our operating table will be a table, but it'll be a table of numbers. It'll be an Excel spreadsheet. This Excel spreadsheet implements all of GPT-2 Small entirely in pure Excel functions.

No API calls, no Python. In theory, you can understand GPT-2 just by going tab by tab, function by function through this spreadsheet. But you wanna hold onto those VLOOKUPs because there's over 150 tabs and over 124 million cells for every single one of the parameters in GPT-2 Small.

I will give you the abbreviated tour. So we'll do three things today in our little med school. First, we'll study the anatomy of our patient, how he's put together.

Then we're gonna put him through a virtual MRI to see how he thinks. And then finally, we're gonna change his thinking with a little AI brain surgery.

Okay. Let's start with anatomy. You're probably familiar with the concept that large language models are trained to complete sentences, to fill in the blank of phrases like this one.

Mike is quick, he moves. And as a human, you might reasonably guess quickly. But how do we get a computer to do that? Well, here's a fill-in-the-blank that computers are very good at.

Two plus two equals four, right? They're really good at math. In fact, you can make it very complex and they do it very well. So what we're gonna do, in essence, is we're gonna take a word problem and turn it into a math problem.

In order to do that, we take our whole sentence or our phrases and we break them into sub-word units called tokens, and then we map each of those tokens onto numbers called embeddings.

Now, I've shown it for simplicity here as a single number, but in the embedding for each token is many, many, many numbers, as we'll see in a bit. And then instead of the simple arithmetic shown here, we're doing the much more complex math of multi-headed attention and the multi-layer perceptron.

Multi-layer perceptron, just another name for a neural network. And then finally, instead of getting one precise, exact answer like you used to get in elementary school, we're gonna interpret the result as a probability distribution as to what the next token should be.

So here's our setup. We get input text, we turn that text into tokens, we turn those tokens into numbers, we do some number crunching, and then we reverse the process.

We turn the numbers back out into tokens or text, and then get our next-token prediction.

So this handy chart shows where each of those actions maps to one or more tabs inside our friendly patient spreadsheet. Let's take a look. So the first thing you do is we get our prompt, right?

Here the prompt is, "Mike is quick, he moves." And then it will output after about 30 seconds since we're running in a spreadsheet, don't use this in production, the next predicted token of quickly.

So the first step is to split this into tokens. Now, you see that every word here goes into a single token, but that's not always the case. In fact, it's not uncommon to be two or more tokens.

Let me give you some examples. So here's another version of the sheet. Let me zoom this up so you can see it a little better. Right. I've put actually some fake words.

Reinjury is a real word, but funology isn't a real word. Uh, but you know what it means, right? Because it's the word fun with ology put together. Those are the morphemes as linguists like to call them.

And the tokenization algorithm actually is able to recognize that in some cases. Whoa, there we go. Right there.

You see fun split into fun and ology. If we zoom that one up.

There we go. But it doesn't always work. So notice how reinjury got split up right here. It's rain and jury, and that's 'cause the algorithm's a little dumb. It just picks the most common sub-word units it finds in its iterations, and it doesn't always map to your native intuition.

And so in practice, machine learning experts feel like it's a necessary evil. Um, and then the next step is we have to map each of these tokens to the embeddings.

So let's go back to the original one, and that's in this tab here. So we have each of our tokens in a separate row, and then right here, starting in column three, is where our embeddings begin.

So this is row right here. The second row is all the embeddings for Mike. Now, in the case of GPT-2 Small, the embeddings are 768 numbers, so we're starting column three.

So that means if we go to column 770, we will see the last end of this. And so there's the end of our embeddings for Mike. And let's go back.

And each one of these, again, is the embedding for, uh, each token. Okay. Then we get to the layers. This is the heart of the number crunching. So there are two key components.

There's attention, and then the neural network or multi-layer perceptron. And in the attention phase, basically the tokens look around at the other tokens next to them to figure out the context in which they sit.

So the token he might look at the word Mike to look at the antecedent for its pronoun, or moves might look at the word quick because quick actually has multiple meanings.

Quick can mean movement in physical space, it can mean smart as in quick of wit, it can mean a body part like the quick of your fingernail, and in Shakespearean English, it can mean alive or dead, like the quick or the dead.

And seeing that the word moves here helps it disambiguate for the next layer, the perceptron, that, oh, we're talking about moving in physical space. So maybe it's quickly or maybe it's fast or maybe it's around, but it's certainly not something about your fingernail.

So let's see where this is all happening. So these are our layers. Now, there's twelve of them. So this is block zero all the way to block eleven. Each one's a tab.

And then if you go up here, we can't go through all of this in the time we have, but this is one of the attention heads. This is step seven.

This is where you can see where each token is paying attention to every other token. And you'll notice that there's a bunch of zeros up at the top right, and that's because no token is allowed to look forward.

They can only look backwards in time. And you'll see here that Mike is looking at Mike a hundred percent of the time. Higher values mean more attention. These are all normalized to one.

Uh, here is the word he, or the token he, I should say. And you'll notice zero point four eight, so about half of its attention, is focused on its an- the antecedent of its pronoun.

Now, this is just one of many heads. If I scroll to the right, you'll see a lot more. Uh, there aren't always as directly interpretable as that, uh, but it gives you a sense of how the attention mechanism works.

And then if we scroll further down, we'll see the multi-layer perceptron right here. If you know something about neural nets, you know they're just a large combination of, uh, multiplications and additions or a, a ma-matrix multiply.

And so I don't know if you can see this in the back. There's a MMULT, which is how you do an Excel matrix multiply, and that's basically multiplying it times its weight.

And then here we put it through its activation function to get the next prediction. Okay, let's keep going.

Okay. Next, we have the language head, and this is where we actually reverse the process. So what we do is we take the last token and we unembed it and reverse the embedding process we did before, and we probabilistically look at which are the tokens the closest to the final last token's unembedding.

And we interpret that as a probability distribution. Now, if you're at temperature zero, like we are in this spreadsheet, then you just take the thing with the highest probability.

But if your temperature is higher, then you sample it according to some algorithm like beam search. Let's take a look.

And we'll go here. So, um, again, I don't know if you can see in the back, but this function here is basically... There we go.

This function in the back basically is taking block eleven, the output of the very last block. It's putting it through a step called LayerNorm. Then we multiply it, another MMULT, times the unembedding matrix, and these are what are known as our logits.

And then to predict the next most likely token,

we just go to the next one. I don't know if you can see this function. It basically is looking at max of the previous column you saw in the previous sheet.

Um, and it's taking the, the highest probability token just like that, and that's our, our predicted token. We get a token ID, then we look it up in the matrix, and we know what the, the next likely token is.

Okay. So that's the forward pass of how GPT-2 works. But how do all those components work together? So let's take our patient and put him through a virtual MRI so we can see how he thinks.

Before we do that, there's something I forgot to mention. These are called residual connections. Inside every layer, there's an addition operation. And what this lets the model do is it lets it route information around and completely skip any part of these layers, either attention or the perceptron.

And so you can reimagine the model as actually a communication network or a communication stream. So the residual stream here is every one of those tokens and information is flowing through them like an information superhighway.

And what each layer is doing is we've got attention moving information across the lanes of this highway and then the perceptron trying to figure out what the likely token is for every single lane of the highway.

But there are multiple of these layers, so they're really reading and writing to each other information in this communication bus. What we can do is we can do a technique called logit lens.

We can take the language head we talked about earlier and stick it in between every single layer of the network and what was it thinking at that layer. So that's what I've done in this sheet.

So I gave it the prompt, "If today is Tuesday, tomorrow is," and the predicted token is Wednesday. And GPT-2 does this correctly for all seven days. And what you see in this chart is essentially the columns here from three through nine are all those lanes of the information superhighway.

And for example, here at block three, this is the top most predicted token at the last token position. So it predicted not. The second most likely word was gonna be still, then it was gonna be just.

These are all wrong. So let's look for what we know is the right answer, Wednesday. So over here at block zero, we see Wednesday. It's at the bottom of the Tuesday stream for some reason on that highway.

Well, it makes sense it'd be close to Tuesday. And then it completely disappears.

And then, oh, over here towards the last few layers, suddenly we see tomorrow, forever, Tuesday, Friday. It knows we're talking about time, we're talking about days. And it gets Wednesday, but it's still the third most likely token.

And then finally it moves it up to the final position, and then it locks it into place. So what's going on here? Well, a series of researchers, uh, basically took this logit lens technique on steroids and isolated that only four components out of the entire network were responsible for doing this correctly over all seven days.

What they found was that all you needed was the perceptron from layer zero, attention from layer nine, and actually only one head, uh, the perceptron from layer nine, and then attention from layer ten.

And that's kind of what we saw in the sheet, right? At the top, we saw Wednesday, and then it disappeared until the later layers pulled it back up and up in probability at towards the end of the process.

So it's an example of where you can see each layer acting as a communication bus trying to jointly figure out and create what they call a circuit to accomplish a task.

Okay, we are now out of med school and ready for surgery.

So you may have heard about, uh, the pioneering work that Anthropic has done about scaling mono-semanticity. This gave rise to what was known as Golden Gate Claude. It was a version of Claude that was very obsessed with the Golden Gate Bridge.

To some, it felt like it thought it was the Golden Gate Bridge. Uh, conceptually, here's how this process worked. You have a large language model, and then you have this residual stream we talked about earlier, and then you use another AI technique, an autoencoder.

This one's a sparse autoencoder, and you ask it to look at the residual stream and separate it out into interpretable features. And you then try and deduce what each feature is, and then you can actually turn up and down each of these features back in the residual stream in order to amplify or suppress certain concepts.

It turns out a team of researchers led by Joseph Bloom, Neel Nanda, and others are building out sparse autoencoder features for open source models like GPT-2 Small. So here, for example, is layer two's feature 7650.

I don't know if you can see it in the back. It's basically everything Jedi.

So gone to our friendly patient again, and I've taken the vector for

that feature while we wait for Excel to wake up. There it is. That first row is essentially what they call the decoder vector corresponding to Jedi. And then I've basically multiplied by a coefficient, and then I've basically formatted it so that I can inject it right into the residual stream.

So this is the start of the block. You can see that steer block two, it's basically just taking that vector I showed you and adding it into the residual stream.

Simple addition. Now we go to our prompt, and originally, normally you ask GPT-2, Mike pulls out his... Makes sense. He pulls out his phone. But if we turn the Jedi steering vector on, I'll give you one guess what he's probably gonna pull out.

Let's see. Okay, so now we hit Calculate now. Um, and this is where you get to witness the 30 seconds it takes. Um, and while we wait for it to, to run, a couple notes.

So first of all, the way Anthropic did their steering was slightly different, but similar in spirit. There's a few other ways to do this kind of steering. One of those is called representation engineering, where the steering vector is deduced via PCA or Principal component analysis.

And there's another technique called activation steering, where what you do is you take the thing you wanna amplify, like Jedi, and you'd run the model through just on that token, and then you'd run it on something you might wanna suppress, like in this case, phone, and then you'd create a phone-- a Jedi minus phone vector and inject

that into the residual stream. Okay, there it is. There it is. Mike pulls out his lightsaber. There we go. [audience cheering] We have done it. [audience applauding]

Our operation has been a success. We've created the world's first GPT-2 Jedi. Stick that on LM系Siriina. Okay. Uh, well, hopefully I've given you a little better insight into how large language models work, but also why they work.

But the root message I wanna leave with is that to be a better AI engineer, it does help to un-rock the black box. Partly, this is about just knowing your tools and their behavior and their limitations better.

Uh, but also we're in a very fast-moving field, and if you wanna understand the latest research, it helps to know how these work. And then last but not least, when you communicate with non-technical stakeholders, there's very often a perception of magic, and the more you can clear that up, the more you can clear up misunderstandings.

I'll give you just one example of where this bubbles up, where architecture bubbles up to how you use them. So this is the, uh, instructions for RWKV, which is a different type of model.

But the template for a normal transformer's at the top, the template for an RWKV, uh, prompt is at the bottom. And what's interesting is that they recommend you swap the traditional order of instructions and context because the attention mechanism or the pseudo-attention mechanism in RWKV can't look back the same way a regular transformer can.

So it's a great example of where model architecture matters all the way up to prompting. Okay, here are the references for the research we talked about today. And then if you want to learn more, you can go to Spreadsheets-are-all-you-need.ai, and you can download this spreadsheet, and you can run it on your own device.

If you want to see me go through every single step of this spreadsheet, I just launched a course on Maven today, um, and the link to it is on that website as well.

Um, and that's it. Thank you. [upbeat music]