Hello there. Yeah, it's cold here. Um, we cannot be dissuaded from reviewing papers today. We're going to look at 'TokenFormer: Rethinking Transformer Scaling with Tokenized Model Parameters.' This seems to be a collaboration of MOX, Planck Institute for Informatics, Google, and Peking University.

This paper proposes, as it says, the 'TokenFormer,' which is a modification of the Transformer architecture that, as they say, treats model parameters as tokens and therefore introduces a new kind of axis of flexibility in Transformer scaling. And ultimately, that's going to

result in an architecture where you can add parameters to an already trained Transformer or to an already trained model and then kind of just continue training it at that bigger parameter count. Um, in my opinion, it there there's like 5% of an idea and then 95% is like

smoke and mirrors trying to couch things in modern words that have already existed for a long time. And there there are fundamentally nothing new. I don't want to be too harsh from the outset, although I probably just was, but we'll dive into the paper. So first,

what are they attempting to do? They say, look, Transformers uh require the substantial cost of scaling these models remains a significant concern. And they depend on a fixed number of parameters, specifically within their linear projections. And when you try to do any modifications to Transformers, then that

typically requires retraining the entire model from scratch. So they introduce this TokenFormer, which leverages attention um not only for computations among input tokens like a classic Transformer, but also for interactions between tokens and model parameters. So previously, previously you had two types of stuff in

Transformers, you had, um, you you would, you would chunk up your text into different tokens, and then you had the attention mechanism where essentially you do token-token interaction, so tokens paying attention to other tokens and so on, and that giving rise to the next layer or the next representation of

tokens. And then you had these kind of feed-forward networks, um, that would take each token and push it through and make it into the next representation, you know, that separately. So actually both of these contain model parameters, and both of these interactions are uh done by linear

projections. So in the feed-forward layer, what happens is, so token X goes, goes in here, the feed-forward network would have parameters W, and if you have Y here as the output, well that's not the correct one. Let's say, um, X and and X

prime up here. So you would have X prime equal to WX or something like this, like a linear linear projection here. Uh, in the attention mechanism, you do have token-token interactions, but before that you actually, so a, a mention typically consists of some kind of outer product

of uh queries and keys, and that goes through some sort of softmax operation and is multiplied by the values, and that gives you, so this here would be your attention matrix, and then that whole thing would give you the output of the next, the next layer, um, all

the tokens together. So to come up with the Q's and the K's and the V's, you would actually also do X * like WQ, X * WK, X * WV. So also here you have interactions between inputs and model parameters, so even to

facilitate the attention you still have interactions with model parameters and their whole point is well what if I want to modify what if I want to add to these parameters well then I essentially you know my whole thing here changes my whole dimensionality changes and so on

um and I cannot I cannot just use the same model again I I have now a bigger model my whole internals are bigger and therefore I need to retrain everything from scratch and that is maybe not so good maybe we want to not retrain things

from scratch so there are goal is to to replace these interactions here and these interactions here with another attention mechanism um if you know anything about attention that you know that in principle we could just add tokens here right if it weren't for the position embeddings so let's assume we

have no position embeddings we could just add tokens and the exact same mechanism the exact same Transformer could process them no problem so the Transformer itself isn't dependent on the length of the input sequence and they extend that to the parameter space and say well what if if if we use a

attention right here we wouldn't necessarily be dependent on the size of this W Matrix uh and therefore we could just increase it and that allows us to add more parameters to the model okay so that's essentially that um they're going to they're going to end up with experiments

like this one saying look if I have to train a Transformer from scratch it's going to you know if I want to train a 124 million um parameter Transformer it's going to require me some sort of cost of training and I'm going to reach a certain perplexity if I then have to

train a bigger one and I have to start from scratch it is going to require me quite substantially more training than if I can just scale up from my previous size to this one using our technique I waste almost no um no computation here in order to get to that next size and so

on so as I already said they're going to replace in two particular places in the Transformer uh the the linear interactions so first of all you can see here is a classic Transformer and you have this uh qkv projection that's how you obtain the queries keys and values

for the attention that is done via linear projection so what they're going to do is they're going to replace this by an attention mechanism um itself so an attention mechanism is going to give rise to these things right here not a linear

projection and then the feed forward Network also is going to be an attention mechanism so the trainable parameters are going to be these what they call Key param and value param in both cases these are trainable parameters so they're not directly multiplied with the signal but they're supplied to the

attention mechanism um and they are tokens so they the trainable parameters you can like the key parameters consists internally of a set of um of tokens right so there are n tokens right here and the value params obviously as well and then the the way

this works is the input here is used as queries into these um into these keys right here and that defines an attention Matrix that aggregates the values okay so it essentially means that for each um query here you're going to get an output that is a a weighted sum

of whatever the values are weighted by how well the query matches the key that's a standard definition of an attention mechanism. M right, uh, actually in no point of the attention mechanism does it require that you have as many queries as you have keys and values, only

the keys and the value numbers need to match. Um, and then yeah, so you essentially have the freedom of having as many key and value tokens as you want, as long as you have the same amount of each. You can see that this is just a function, it takes the

input signal as an input and it takes the trainable parameters as an input and it gives you a output of in the order in the size of the input signal, so you're just going to do uh the queries which is the input signals times the keys which

is the learnable parameters, softmax, multiply by the values which is also learnable parameters and that's going to be your next layer representation. Uh, so this you're doing this instead of a feed forward network uh with parameters W of X, okay. Um, and the same goes to obtain

like the Q of the actual attention layer, to obtain the K of the actual attention layer and to obtain the V of the actual attention layer you're going to do one of these operations each which gets a bit meta and a bit confusing, but in order to obtain the K of the attention

layer um you're going to do an attention mechanism of the input signal with the key and value parameters, so you're going to do the input signal X um times the key parameters for coming up with attentions, K, softmax, aggregate the value parameters of

attention K K right uh now I got even confused so you have separate parameters for coming up with the K separate parameters for coming up with the V separate parameters for coming up with the Q just as if you were to do of K equals W K X right so just as if you had a

linear projection um where you have separate parameters for coming up with the keys the queries and the values so I hope you can imagine something along that and you might think oh wow that's a neat idea all right because I can now just add parameters here and especially

if I zero initialize the one of the two only one of the two has to be zero initialized um for example the the keys I guess uh no let's say let's say the values are zero initialized right uh you can aggregate as much as you want the

values will will the new values will never actually um do anything uh except you know once they're actually trained start training start changing their value so you can just on the fly add parameters right here and you will not change anything about the model so that's pretty

good now why do I have a bit of my gripes with this work so yeah they go through everything here you can see that this is a diagram of essentially what I've just shown now contrary to before the diagram goes goes uh top down right

here so you can see this here replaces the traditional attention mechanism and then this this here replaces the traditional uh feed forward uh mechanism and yeah also here you can see that this essentially acts as queries this essentially acts as keys this as values so you have a matching attention

scores uh using Softmax and then a weighted sum of the values which gives you the output and if you have old ones you can add new ones and they say here somewhere how you initialize them you initialize them with zeros here so we augment this set by appending

new key value parameter tokens as this um so you concatenate old and new key tokens all and new value tokens and this scaling scheme permits the integration of an arbitrary number of parameters without altering the input or output dimensions by initializing the keys okay the keys um with zero similar

to Laura our model can perfectly resume the model state from pre-training phase without losing the well-learned knowledge facilitating easier convergence and accelerating the overall scaling process all right so I have essentially two problems with this paper one is even if you take it at kind of

face value that this is a new thing this is novel this is different and so on if you actually closely look at their curves that I've shown you then it's it's kind of odd so first of all uh here they say what we did is we trained um

one from scratch right and then one incrementally now the the one from scratch if I recall correctly or this could be the the one further down I think is the more elaborate curve right they the one from scratch here is trained with 300 billion tokens right um

and the other ones are trained and here it says 15B 30B and 60B what's actually happening is that the first one here is also trained with 300 billion tokens and then and then you add an additional 15

billion tokens or 30 or 60 billion tokens to get the respective curves right here so in in order for this actually to make sense and to give you a benefit you assume that your comparison is someone training a classic transformer for the full duration for

all the sizes right so you you kind of consider someone saying like Okay I'm going to train this one and this one and this one and this one and compared to someone like this if you actually want to go stepwise through all the sizes this is a benefit because

it starts from uh a essentially it starts from an already trained smaller version now what I find weird first of all is that even at the smallest level like the Baseline they're different like this this method here already outperforms for some reason the classically even though they're both

just initially trained with 300 billion tokens which I don't know already feels like a lot of what a lot of papers do is they will find good hyperparameters for their model their whatever they're doing and then they'll just say like we just use those hyperparameters everywhere

which I think I've read in this paper as well which obviously is then you know it's it's good hyperparameters for you it's good settings for you and what so okay so they already start um with you know further down but then what's

interesting is that for the same size for example these sizes right here uh this one's better like yes it costs more to get there but this one's better and if you actually consider that someone has actually skipped the lowest one and just says well I want to train a

Transformer with 354 million parameters, they're going to train it for this, you know, for this much, um, they're going to go through 300 billion tokens right now. These models here have gone presumably through 300 billion plus in the yellow case, 60 billion tokens so

through more tokens and they're worse. That's a bit what I find suspect here is that also here you can see this is, this went through 300 billion tokens whereas this here presumably went through 300 billion at this size plus 60 at least

right, in order to get here and then it's still worse. Like goes through more tokens and it's still worse, um, that's a bit to me, yeah, suspect. Also, then I don't know what this, um, training cost here actually represents. I'm just going to

assume it represents training this particular model from scratch and not training the sequence of these models from scratch, uh, but I can see that, you know, once you're bigger, your cost obviously goes up, um, and that's what makes the cost lower. So the only thing here is right

they can say, look, we have a lower kind of total cost of getting there, but then they kind of end up at a worst place, which I mean, it's fine, but I just wanted to point out that even these models they start at the number of

tokens that the from-scratch models have as their final state. Okay, the second thing is, um, and that's a bit more crucial in my opinion, their framing of this entire thing. So their framing of, oh, we're going to introduce new parameters and the parameters are tokens and whatnot, if you

look at the traditional transformer it's let's just look at the feed forward feed forward part of a traditional Transformer I previously said you have a token you push it through and it gets you a new one right so let's call that X let's call that X

prime and here we have a set W that's actually not the whole story even the very first attention is all you need Transformer actually considered a token going through an up projection right which we call let's call that W1 and then a down projection again let's call

that W2 and that will give you um X Prime and in the middle there's some sort of a nonlinearity okay so the actual thing was we have x * W1 nonlinearity reu or something W2 and that gives you X Prime now you

can see that also here we have a free parameter let's call that M because they're calling it n we have a free parameter we can make this inner dimension as large or as little as we want and the rest of the architecture isn't affected at all which is one of

the things they say is suddenly possible with their architecture because they can add tokens right the second like the second thing is I can also here start from scratch like if I just call this if I just call W1 K Tilda and I call W2 V Tilda you'll

be able to see that oh what I'm doing is I'm multiplying X by K Tilda right whether this is transposed or not right who cares it's a linear operation I have some nonlinearity and then I have V Tilda and then it looks

all of a sudden a whole lot like what we had there and the same thing applies if I want to add parameters I can just take my K Tilda and I can add depending on whether you consider row or column multiplication and I can just add a

bunch of zero columns right like so and as long as I as long as to V I add the corresponding zero rows um or not even I just have to add rows just have to add rows then it will be exactly the same so I can just

fill in my K lower sized K and then add zeros and it will give me the exact same result while increasing my parameter so also this has long been previously possible um like so and I would argue It's actually an inferior thing because uh people who have done this in the past

and uh myself included in that uh it's probably better to not do this but to use some sort of actual up projection if you want to use some kind of lower trained model and transfer it to a a bigger model uh some sort of like um

orthogonal projection and so on they have really nice mathematical properties whereas filling this up with zeros will kind of give you a scaling issue in some sense um so you might want to actually try that but nevertheless the zero zero adding has been done the even even

experiments in changing this Dimension here has been done if you look at the original Transformer paper they actually have ablations varying this inner Dimension while keeping the rest of the architecture completely the same neither the original Transformer nor this paper manages to actually change the

dimensionality of the actual tokens because in order to do that, then you would actually have to, like, there's no way to just add zeros to something. Uh, you're actually going to change the forward propagated signal. There's actually a way to do it, um, if

you look at what they do in the attention in the uh, kind of attention part here, you could just add uh appropriate zeros and then kind of your, if you go from an X to a to Q right, uh, you could, if this is your original vector, you could just add a bunch of

zeros here and if you do that consistently, you essentially your inner products with the K's would kind of null out here and you would get the same inner products down here modulo some scaling factor. So even there, you can add zeros. So the only thing, if you actually

compare it, that this paper does new, if we write this side by side, is it will multiply X by their parameter key, key parameter. It will then do aggregate the value parameters and it does a softmax here, a scaled softmax instead of a ReLU, and it like it uses the same

mechanism inside of attention as well instead of just, but also that like you could just say, well, instead of obtaining our Q values by doing WX, we could just obtain our Q values instead by doing W2 uh nonlinearity W1 of X, right? Have a

bit of a more powerful representation in order to come up with these intermediate values and that's essentially it. Um, the rest that this paper is is just couching this change in nonlinearity into the language of tokens, token parameter interactions, token-token interactions, scaling flexibility, and

whatnot um so yeah that is a bit I don't know like I feel like even though it's like even that would be possible but then they don't mention that they they never and if yeah if you look at the formula yeah it's they they never

mention that they never say hey look even the original Transformer paper essentially did what we're doing right here but we kind of have a new way of looking at it that would also be fine but the only place where they compare to like anything classic is this um oh we

have this net to net way of adding parameters to a neural network and we're going to compare to that and we're going to be somewhat better here and that's it now there is a slight chance there's a slight chance that even the authors thought that they have

something super new because you know once you start thinking in this oh ah we're going to replace it by a token attention mechanism and whatnot yeah you tend to be a bit um a bit driven into this world by yourself but who knows um yeah so all in all like looking at

the technique by itself I actually think it's is quite okay it's probably a good way of messing with one part of the model size like with there is a certain flexibility here where you can add parameters not like it's adding parameters in a distinct way

that influences one part of the model it's it's not like you cannot change all of the architecture you cannot change representational you cannot add representational capacity to the forward signal itself what you can essentially do is you can add computational capacity like the complexity of

transforming, um, a signal from one layer into the next layer here that you can change with this method. You cannot change the fundamental carrying capacity of the forward signal with this method right here. So there it's a way to modify one aspect of the Transformer model that has already been present at

least in the feed-forward layer in the very first Transformer paper. Uh, if you want to argue you can say this paper extends that also to the computation of the attention inputs, um, and that's a cool thing and you might want to look at stuff in this way in order to understand

them better, in order to extend your freedom of experimentation. On the other hand, yeah, as I said, a lot of this is just word couching, and if you actually write down what it does, you will find that it's essentially a different nonlinearity, and that's it. All right.

This was my uh, look through this paper and I hope, I hope that wasn't too harsh, um, I, yeah, again I do think like the research in itself is is pretty good and is a good way of thinking about stuff. All right, if you have different

opinions, please let me know and I'll see you next time. Bye-bye.

TokenFormer: Rethinking Transformer Scaling with Tokenized Model Parameters (Paper Explained)

I make videos about machine learning research papers, programming, and issues of the AI community, and the broader impact of AI in society.

Twitter: https://twitter.com/ykilcher
Discord: https://ykilcher.com/discord
BitChute: https://www.bitchute.com/channel/yannic-kilcher
LinkedIn: https://www.linkedin.com/in/ykilcher
BiliBili: https://space.bilibili.com/2017636191

If you want to support me, the best thing to do is to share out the content :)

If you want to support me financially (completely optional and voluntary, but a lot of people have asked for this):
SubscribeStar: https://www.subscribestar.com/yannickilcher
Patreon: https://www.patreon.com/yannickilcher
Bitcoin (BTC): bc1q49lsw3q325tr58ygf8sudx2dqfguclvngvy2cq
Ethereum (ETH): 0x7ad3513E3B8f66799f507Aa7874b1B0eBC7F85e2
Litecoin (LTC): LQW2TRyKYetVC8WjFkhpPhtpbDM4Vw7r9m
Monero (XMR): 4ACL8AGrEo5hAir8A9CeVrW8pEauWvnp1WnSDZxW7tziCDLhZAGsgzhRQABDnFy8yuM9fWJDviJPHKRjV4FWt19CJZN9D4n




Yannic Kilcher

트랜스포머 아키텍처를 수정하는 협업, 토큰포머에 대한 논문 리뷰.

토큰포머는 모델 파라미터를 토큰으로 취급하여 확장에 유연성을 더합니다.

비평:  대부분 기존의 아이디어를 현대적 용어로 재포장한 것입니다.

트랜스포머를 확장하고 처음부터 다시 교육하는 데 드는 높은 비용을 해결합니다.

토큰과 모델 매개변수 간의 상호작용에 대한 주의 사항을 소개합니다.

토큰포머의 메커니즘에 대한 설명

클래식 트랜스포머는 선형 투영을 통해 주의 및 피드포워드 네트워크를 통해 토큰과 토큰 간 상호작용을 합니다.

피드 포워드 레이어(WX)의 선형 투영을 보여줍니다.

주의 집중 메커니즘의 선형 투영(WQ, WK, WV)에 대해 설명합니다.

문제: 확장 시 차원이 변경되어 재교육이 필요합니다.

솔루션: 선형 상호작용을 주의 메커니즘으로 대체하여 매개변수를 추가할 수 있도록 합니다.

실험 결과, 처음부터 다시 교육하는 것에 비해 효율적인 확장이 가능했습니다.

주의 및 피드 포워드 네트워크의 선형 투영을 주의 메커니즘으로 대체합니다.

학습 가능한 파라미터('키 파라미터' 및 '값 파라미터')는 주의 메커니즘에 제공되는 토큰입니다.

실험 설정 및 결과에 대한 비판, 불일치 및 의심스러운 비교.

프레임 및 신규성 주장에 대한 비판; 기존 방식은 이미 유사한 매개변수 추가를 허용하고 있습니다.

기존 방법과의 비교 및 전반적인 평가

기존 트랜스포머의 피드 포워드 네트워크와 내부 차원 유연성을 비교합니다.

비판:  제로 패딩은 모델 확장을 위한 다른 방법보다 열등합니다.

토큰 차원 변경의 한계에 대해 논의합니다.

이 논문의 주요 기여는 새로운 용어와 함께 제시된 다른 비선형성입니다.

전반적인 평가: 이 기술은 모델의 한 측면을 수정하는 데 유용하지만 진정한 참신함이 부족합니다.