Models & Algorithms•SOTAAZ Lab••EN

트랜스포머 블록 15가지 변화: 2017년 원조부터 Mamba 하이브리드까지, 13가지는 코드로 실제 층과 맞춰 봤습니다

Post-LN에서 Mamba 하이브리드까지 트랜스포머 블록의 15가지 변화를 그림 하나씩으로 정리하고, 논문이 보고한 이득과 대가를 붙였습니다. 실제 모델 일곱 개의 층을 짧은 PyTorch 함수로 다시 짜서 Hugging Face 출력과 맞춰 봤고, 일곱 개 모두 반올림 오차 안에서 같았습니다. 같은 문장을 넣으면 층마다 더해지며 올라가는 본 흐름(잔차 스트림)이 첫 층 대비 Qwen3-0.6B에서는 98배, BERT에서는 1.1배가 됩니다.

트랜스포머 블록 15가지 변화: 2017년 원조부터 Mamba 하이브리드까지, 13가지는 코드로 실제 층과 맞춰 봤습니다

BERT, GPT-2, Pythia, Qwen3, Gemma 3, Jamba, Granite-4.0-H 일곱 모델에 같은 문장을 넣고, 층을 하나 지날 때마다 마지막 토큰의 벡터가 얼마나 커지는지 쟀습니다. Qwen3-0.6B-Base에서는 마지막 층을 지난 벡터가 첫 층을 지난 벡터의 98배였습니다. BERT에서는 1.1배로 거의 그대로였습니다. 두 모델은 어텐션, 피드포워드 망, 정규화라는 같은 부품으로 만들어졌지만, 그 밖에도 다른 점이 많습니다. 그중 이 그래프에 바로 드러나는 차이가 하나 있습니다. 층을 지나며 칸의 출력이 계속 더해지는 벡터를 이 글에서는 본 흐름이라고 부르겠습니다(흔히 잔차 스트림이라고 합니다). BERT는 더하기가 끝날 때마다 본 흐름 자체를 다시 정규화하고, 나머지 여섯 모델은 본 흐름을 한 번도 정규화하지 않습니다. 그래서 BERT 선만 평평합니다. 정규화를 어디에 두느냐는 이 글에서 살펴볼 15가지 변화 중 하나입니다.

같은 문장을 넣었을 때 일곱 모델에서 본 흐름이 첫 층부터 마지막 층까지 얼마나 커지는지 보여 주는 선 그래프. 가로축은 층 위치를 전체 층 수로 나눈 비율, 세로축은 로그 눈금으로 첫 층 뒤 크기 대비 배율입니다. Qwen3-0.6B-Base는 약 98배, Gemma-3-1B-it는 47배, Jamba-tiny-dev는 31배, Pythia-70m은 14배, GPT-2는 9.9배, Granite-4.0-H-350M은 9.3배로 끝납니다. 일곱 중 유일한 Post-LN 모델인 BERT-base는 내내 0.56배에서 1.1배 사이에 머뭅니다.

앞 글에서는 토큰 하나가 GPT-2, Qwen3, Granite를 지나가는 길을 따라갔습니다. 층마다 하는 일은 같았습니다. 정규화하고, 토큰끼리 정보를 섞고, 그 결과를 원래 벡터에 더합니다. 다시 정규화하고, 토큰마다 피드포워드 망(FFN)으로 변환하고, 또 더합니다. 이번 글은 2017년 이후 이 칸들을 무엇으로 채우고, 어떻게 잇고, 어떻게 쌓아 왔는지를 다룹니다. 변화마다 움직이는 그림 하나, 논문이 보고한 결과, 그 대가를 붙였습니다. 어텐션 계산 자체(헤드, KV 캐시, 그룹 쿼리, 희소·선형 어텐션)는 어텐션 정리 글에서 다뤘으니, 여기서는 어텐션을 칸 하나로만 봅니다.

코드를 어떻게 확인했는가

이 글의 블록마다 짧은 PyTorch 함수가 붙어 있습니다. 이 함수가 저희가 논문을 읽고 짐작한 블록이 아니라 실제 모델의 블록이라는 것을 보이려고, 실제 모델과 직접 비교했습니다. 순서는 이렇습니다.

  1. Hugging Face에서 모델을 불러와 "In the morning, Alice gave Bob a book. Later, Bob gave the book back to"라는 문장을 넣습니다.
  2. 모델이 도는 동안 층마다 들어간 값과 나온 값을 기록합니다. PyTorch에서는 이런 기록 장치를 forward hook이라고 부릅니다.
  3. 층 하나의 가중치를 꺼내 저희 함수에 같은 입력을 넣고, 그 출력을 실제 층이 낸 출력과 비교합니다.
python
io = {}
def hook(i):
    def f(mod, args, kwargs, out):
        x = args[0] if args else kwargs["hidden_states"]   # i번 층에 들어간 값
        y = out[0] if isinstance(out, tuple) else out       # 나온 값
        io[i] = (x[0].clone(), y[0].clone())
    return f
hs = [l.register_forward_hook(hook(i), with_kwargs=True) for i, l in enumerate(layers)]
model(ids)

x, y = io[5]                                     # 5번 층
ours = pre_ln_block(x, weights_of_layer_5, n_heads, eps)
print((ours - y).abs().max())                    # 모든 숫자 중 가장 큰 차이

CPU에서 float32로, 일곱 모델의 층 22개를 이렇게 비교했습니다(전체 스크립트는 글 끝의 재현 묶음에 있습니다). 가장 큰 차이를 실제 출력의 가장 큰 값으로 나눈 상대 차이는 Pythia 마지막 층의 3.9e-5가 최대였고, 나머지는 모두 2.2e-7 이하였습니다. Pythia 마지막 층만 눈에 띄게 커서, Pythia 세 층을 float64로 다시 비교했습니다. 그 층의 차이는 5.4e-13으로, 나머지 두 층은 2.3e-15 이하로 줄었습니다. 계산 정밀도를 올리자 차이가 함께 줄었으니 계산이 달라서 생긴 차이가 아니라 반올림 차이입니다. 즉 함수가 모델과 같은 계산을 합니다.

모델확인하는 것비교한 층가장 큰 상대 차이
BERT-basePost-LN0, 5, 112.2e-7
GPT-2Pre-LN0, 5, 111.8e-7
Pythia-70m병렬 블록, 일부 차원만 RoPE0, 2, 53.9e-5
Qwen3-0.6B-BaseRMSNorm, QK 정규화, RoPE, SwiGLU0, 14, 271.4e-7
Gemma-3-1B-it칸 앞뒤 정규화2, 5, 254.5e-8
Jamba-tiny-devMamba, MoE, 위치 없는 어텐션3, 4, 5, 129.4e-8
Granite-4.0-H-350MMamba-2, 위치 없는 어텐션0, 10, 311.6e-7

아래에 나오는 코드가 이 비교를 통과한 코드입니다. 인코더·디코더 원조와 Hymba 두 항목은 그림과 논문 수치로 설명합니다.

출발점

1. 원조 블록 (2017)

원조 트랜스포머 블록. 왼쪽은 인코더 층으로, 셀프 어텐션 뒤 x에 더하고 LayerNorm, ReLU FFN 뒤 더하고 LayerNorm을 합니다. 오른쪽 디코더 층에는 마스크 셀프 어텐션과 FFN 사이에 인코더를 읽는 크로스 어텐션이 하나 더 있습니다. 두 층 모두 LayerNorm(LN)이 더하기 뒤 본 흐름 위에 있습니다.

"Attention Is All You Need"(Vaswani et al., 2017)는 번역 모델을 인코더와 디코더 각 6층으로 만들었습니다. 각 칸은 LayerNorm(x + Sublayer(x)) 형태로 감쌉니다. 칸을 계산해 x에 더한 다음, 그 합을 정규화합니다. 더하기 뒤에 정규화가 오므로 Post-LN이라고 부릅니다. FFN은 행렬 두 개 사이에 ReLU를 둔 구조로, 바깥 폭이 512, 안쪽 폭이 2,048입니다. 위치는 고정된 사인파를 입력에 더해 넣었습니다. 학습하는 위치 벡터도 시험했는데, 두 방식 모두 BLEU 25.7로 같았다고 보고합니다(Table 3, E행).

BERT는 인코더에 이 블록을 그대로 썼고(FFN만 GELU), 그래서 Post-LN 예시로 BERT-base를 씁니다.

python
def post_ln_block(x, sd, H, eps):
    q = heads(x @ sd["attention.self.query.weight"].T + sd["attention.self.query.bias"], H)
    k = heads(x @ sd["attention.self.key.weight"].T + sd["attention.self.key.bias"], H)
    v = heads(x @ sd["attention.self.value.weight"].T + sd["attention.self.value.bias"], H)
    a = merge(attend(q, k, v, 1 / math.sqrt(q.shape[-1]), causal=False))
    a = a @ sd["attention.output.dense.weight"].T + sd["attention.output.dense.bias"]
    x = layer_norm(x + a, sd["attention.output.LayerNorm.weight"], sd["attention.output.LayerNorm.bias"], eps)
    f = F.gelu(x @ sd["intermediate.dense.weight"].T + sd["intermediate.dense.bias"])
    f = f @ sd["output.dense.weight"].T + sd["output.dense.bias"]
    return layer_norm(x + f, sd["output.LayerNorm.weight"], sd["output.LayerNorm.bias"], eps)

여기서 x가 처음에 말한 본 흐름입니다. layer_norm(x + ...) 두 줄을 보면 본 흐름 자체를 층마다 두 번 다시 정규화합니다. 첫 그래프에서 BERT 선이 평평한 이유가 이것입니다.

2. 디코더만 남기기

왼쪽은 마스크 셀프 어텐션, 크로스 어텐션, FFN이 있는 원조 디코더 층. 오른쪽은 2018년 GPT 층으로, 마스크 셀프 어텐션과 GELU FFN만 남았습니다.

글을 이어 쓰기만 하는 언어 모델에는 읽어 올 원문이 없습니다. 그러니 인코더도, 인코더를 읽는 크로스 어텐션도 필요 없습니다. GPT(Radford et al., 2018)는 마스크 셀프 어텐션과 FFN으로 된 디코더 층을 12개 쌓았습니다. 폭은 768, FFN 안쪽은 3,072입니다. FFN 활성화 함수를 GELU로 바꾸고 사인파 대신 학습하는 위치 벡터를 쓴 것도 이 논문입니다. 아래에 나오는 모델은 거의 모두 이렇게 디코더 층만 쌓은 구조에서 칸만 바꾼 것입니다.

정규화 칸

3. Pre-LN: 본 흐름 대신 복사본을 정규화합니다

왼쪽은 Post-LN으로, 더하기 뒤 본 흐름 위에 LN이 있습니다. 오른쪽은 GPT-2의 Pre-LN으로, 어텐션과 FFN에 들어가기 직전 가지 시작점에 LayerNorm이 있고 본 흐름에는 아무것도 없습니다.

GPT-2(Radford et al., 2019)가 GPT에서 바꿨다고 밝힌 것은 셋입니다. LayerNorm을 각 칸의 입력 쪽으로 옮겼고, 마지막 층 뒤에 LayerNorm을 하나 더 넣었고, 초기화 때 잔차 가중치를 1/√N로 줄였습니다. 코드로 보면 BERT와 다른 점은 정규화 호출 위치뿐입니다.

python
def pre_ln_block(x, sd, H, eps):
    D = x.shape[-1]
    h = layer_norm(x, sd["ln_1.weight"], sd["ln_1.bias"], eps)      # 복사본을 정규화
    q, k, v = (heads(t, H) for t in (h @ sd["attn.c_attn.weight"] + sd["attn.c_attn.bias"]).split(D, -1))
    a = merge(attend(q, k, v, 1 / math.sqrt(D // H)))
    x = x + a @ sd["attn.c_proj.weight"] + sd["attn.c_proj.bias"]   # 정규화하지 않은 본 흐름에 더함
    h = layer_norm(x, sd["ln_2.weight"], sd["ln_2.bias"], eps)
    f = F.gelu(h @ sd["mlp.c_fc.weight"] + sd["mlp.c_fc.bias"], approximate="tanh")
    return x + f @ sd["mlp.c_proj.weight"] + sd["mlp.c_proj.bias"]

왜 나아졌는가. Xiong et al. (2020)은 Post-LN 모델이 초기화 직후 출력 가까운 층에서 기울기가 크기 때문에, 학습률을 처음에 천천히 올리는 웜업 없이는 학습이 잘 안 된다는 것을 보였습니다. IWSLT14 독일어-영어 번역에서 웜업 없는 Post-LN은 BLEU 8.45에 그쳤고, 웜업을 넣으면 약 34였습니다. Pre-LN은 기울기가 안정적이라 웜업을 뺄 수 있습니다. BERT 사전 학습에서는 Pre-LN이 검증 손실 약 1.69에 50만 스텝 무렵 닿았고 Post-LN은 70만 스텝 무렵 닿았습니다(Figure 5a). 논문은 이를 40% 빨라졌다고 적습니다.

대가는 무엇인가. 층을 지나는 동안 본 흐름을 한 번도 정규화하지 않으니, 층마다 더한 값이 계속 쌓입니다. 첫 그래프에서 커지는 선들이 그 모습입니다. GPT-2에서 마지막 토큰 벡터의 크기는 1번 층 뒤 51.6에서 12번 층 뒤 512.1이 됩니다. 크기는 출력 직전의 마지막 정규화(GPT-2가 추가한 그 LayerNorm)에서 정리합니다.

4. RMSNorm: 평균 빼기를 생략합니다

왼쪽은 GPT-2의 Pre-LN 자리에 있는 LayerNorm. 오른쪽은 Llama와 Qwen3처럼 같은 자리에 RMSNorm을 둔 블록입니다.

LayerNorm은 벡터에서 평균을 빼고 표준편차로 나눈 뒤, 가중치를 곱하고 편향을 더합니다. RMSNorm(Zhang and Sennrich, 2019)은 크기 맞추기만 남깁니다. 제곱평균제곱근으로 나누고 가중치를 곱하는 것이 전부입니다.

python
def rms_norm(x, w, eps, plus_one=False):
    y = x * torch.rsqrt(x.pow(2).mean(-1, keepdim=True) + eps)
    return y * (1 + w) if plus_one else y * w           # Gemma는 (1 + w)를 곱합니다

논문이 보고한 것. Transformer-base 번역 모델에서 학습 1,000스텝에 걸리는 시간이 248초에서 231초로 6.9% 줄었고(Table 4), newstest2014 BLEU는 26.6과 26.8이었습니다. 초록의 "7%에서 64%"라는 범위에는 RNN 모델이 들어 있고, 트랜스포머에서는 RMSNorm이 6.9%, 일부 차원만 쓰는 변형인 pRMSNorm이 9% 빨랐습니다. 대가: 평균을 맞추는 기능이 빠진다는 것 말고는 따로 적힌 것이 없고, 저자들은 그 기능이 필요 없다고 주장합니다.

5. 칸 앞뒤에 정규화 (Gemma 2, 3)

왼쪽은 Qwen3 같은 Pre-LN 블록. 오른쪽은 Gemma 2, 3으로, 어텐션 앞에 RMSNorm을 두고 어텐션 출력을 더하기 전에 또 한 번 RMSNorm을 합니다. FFN 앞뒤도 마찬가지입니다.

Gemma 2(Gemma Team, 2024)는 "각 트랜스포머 칸의 입력과 출력"을 정규화하고, Gemma 3(Gemma Team, 2025)도 이를 유지합니다. 그래서 Gemma 3 층 하나에는 정규화가 네 개 있습니다. input_layernorm, post_attention_layernorm, pre_feedforward_layernorm, post_feedforward_layernorm입니다.

python
def sandwich_block(x, sd, Hq, Hkv, d, eps, theta, scale):
    pos = torch.arange(x.shape[0])
    n = lambda t, name: rms_norm(t, sd[name], eps, plus_one=True)
    h = n(x, "input_layernorm.weight")
    q = n(heads(h @ sd["self_attn.q_proj.weight"].T, Hq), "self_attn.q_norm.weight")
    k = n(heads(h @ sd["self_attn.k_proj.weight"].T, Hkv), "self_attn.k_norm.weight")
    v = heads(h @ sd["self_attn.v_proj.weight"].T, Hkv)
    q, k = rope(q, pos, theta), rope(k, pos, theta)
    a = merge(attend(q, k, v, scale)) @ sd["self_attn.o_proj.weight"].T
    x = x + n(a, "post_attention_layernorm.weight")                  # 출력을 정규화한 뒤 더함
    h = n(x, "pre_feedforward_layernorm.weight")
    g, u = h @ sd["mlp.gate_proj.weight"].T, h @ sd["mlp.up_proj.weight"].T
    f = (F.gelu(g, approximate="tanh") * u) @ sd["mlp.down_proj.weight"].T
    return x + n(f, "post_feedforward_layernorm.weight")

가중치 이름을 읽을 때 헷갈리기 쉬운 곳이 있습니다. Llama와 Qwen3의 post_attention_layernorm은 FFN 앞의 정규화입니다. Gemma에서는 이름대로 어텐션 출력에 적용됩니다.

출력 쪽 정규화는 각 칸이 더하는 양을 제한하지만, 본 흐름 자체는 여전히 정규화하지 않습니다. 그래서 Gemma의 본 흐름도 커지고, 첫 그래프에서는 47배였습니다. GPT-2의 9.9배보다 크지만, 두 모델은 크기와 학습도 다르므로 이 그래프로 출력 쪽 정규화의 효과만 떼어 볼 수는 없습니다. 논문이 보고한 것: 이유는 "학습을 안정시키기 위해"라고만 적혀 있고, 두 보고서 모두 이 변화에 대한 수치는 없습니다. 대가: 층마다 정규화 호출이 두 번 늘어납니다.

6. QK 정규화: 쿼리와 키를 정규화합니다

왼쪽은 GPT-2 같은 어텐션 가지로, 정규화, Q/K/V 투영, 점수 q·k, v의 가중합 순서입니다. 오른쪽은 Qwen3, Gemma 3처럼 투영과 점수 사이에 q와 k를 헤드마다 RMSNorm하는 단계가 들어갑니다.

어텐션 점수는 쿼리와 키의 내적입니다. 학습 중에 두 벡터가 커지면 점수도 커지고, softmax가 가중치를 거의 한 토큰에 몰아 줍니다. ViT-22B(Dehghani et al., 2023)가 매개변수 약 80억 개 규모에서 바로 이 문제를 겪었습니다. 어텐션 로짓이 지나치게 커지면서 학습이 발산했습니다. 정규화를 넣지 않은 실험에서는 로짓의 크기가 "50000을 넘게" 커졌다고 적었습니다. 이들이 Gilmer et al. (2023)의 방법이라고 밝히며 쓴 해결책은 내적 전에 쿼리와 키에 LayerNorm을 거는 것이었습니다. 그보다 앞선 Henry et al. (2020)은 학습하는 배율을 곱한 L2 정규화를 썼고, 자원이 적은 번역 언어쌍 다섯 개에서 평균 0.928 BLEU가 올랐다고 보고합니다.

Qwen3(Yang et al., 2025)는 Qwen2의 QKV 편향을 없애고 "안정적인 학습을 위해" QK 정규화를 넣었습니다. Gemma 3는 Gemma 2의 로짓 소프트 캡을 이것으로 바꿨습니다. Qwen3에서는 q와 k에 헤드마다 RMSNorm을 하나씩 거는 두 줄이 늘어날 뿐입니다.

python
def qwen3_block(x, sd, Hq, Hkv, d, eps, theta):
    pos = torch.arange(x.shape[0])
    h = rms_norm(x, sd["input_layernorm.weight"], eps)
    q = rms_norm(heads(h @ sd["self_attn.q_proj.weight"].T, Hq), sd["self_attn.q_norm.weight"], eps)
    k = rms_norm(heads(h @ sd["self_attn.k_proj.weight"].T, Hkv), sd["self_attn.k_norm.weight"], eps)
    v = heads(h @ sd["self_attn.v_proj.weight"].T, Hkv)
    q, k = rope(q, pos, theta), rope(k, pos, theta)
    x = x + merge(attend(q, k, v, 1 / math.sqrt(d))) @ sd["self_attn.o_proj.weight"].T
    return x + swiglu(rms_norm(x, sd["post_attention_layernorm.weight"], eps), sd)

이 함수 하나에 4번, 7번, 10번 항목도 같이 들어 있습니다. 대가: 정규화마다 작은 가중치 벡터(Qwen3-0.6B에서는 각 128개)가 생기고, 층마다 정규화 호출이 두 번 늘어납니다.

위치 칸

7. RoPE: 어텐션 안에서 위치만큼 회전합니다

왼쪽은 GPT-2로, 첫 층에 들어가기 전에 학습한 위치 행을 토큰 행에 한 번 더합니다. 오른쪽은 Qwen3로, 토큰 행만 들어가고 어텐션 층마다 q와 k를 위치만큼 회전합니다.

GPT-1과 GPT-2는 맨 아래에서 토큰 벡터마다 학습한 위치 벡터를 한 번 더합니다. GPT-2의 위치 행은 1,024개라 그보다 긴 입력은 받지 못합니다. RoPE(Su et al., 2021)는 그 대신 어텐션 층마다 q와 k의 숫자를 두 개씩 짝지어 위치에 비례하는 각도로 회전합니다. 그러면 회전한 두 벡터의 내적이 두 토큰 사이의 거리에 따라 정해집니다. rope 함수와 이 성질을 확인한 과정은 앞 글에 있습니다.

논문이 보고한 것: WMT14 영어-독일어에서 Transformer base의 27.3 대비 27.5 BLEU였고, 중국어 법률 문서 짝 맞추기 과제에서는 BERT 기준선 67.77% 대비 512토큰에서 68.29%, 1,024토큰에서 69.79%였습니다. 저자들이 밝힌 한계: 왜 기준 모델보다 빨리 수렴하는지 "충분한 설명이 없다"고 적었습니다. Pythia는 각 헤드의 앞 4분의 1에만 RoPE를 겁니다(아래 parallel_block의 rot_frac = 0.25). Qwen3-Next의 어텐션 층도 같은 방식입니다.

8. NoPE: 위치 신호를 아예 넣지 않습니다

왼쪽은 q와 k를 위치만큼 회전하는 Qwen3 어텐션. 오른쪽은 Granite-4.0-H와 Jamba로, 같은 어텐션에서 회전도 위치 행도 없고 인과 마스크만 남아 있습니다.

디코더는 위치 인코딩이 없어도 위치 정보를 어느 정도 가집니다. 인과 마스크 때문에 10번 토큰은 앞 토큰 10개를 보고, 3번 토큰은 3개만 봅니다. Kazemnejad et al. (2023)은 매개변수 약 1억 700만 개의 작은 디코더 모델을 합성 추론 과제로 학습시켰고, 위치 인코딩을 아예 넣지 않은 모델이 학습 때보다 긴 입력에서 함께 시험한 다른 방식들보다 잘 버텼습니다. 밝힌 한계: 대규모 사전 학습은 시험하지 못했고, 10억 개 규모 실험에서는 가장 긴 길이에서 ALiBi가 NoPE보다 안정적이었습니다.

하이브리드 모델이 NoPE를 쓰는 이유는 따로 있습니다. Jamba 논문(Lieber et al., 2024)은 "Mamba 층이 있으면 위치 임베딩이나 RoPE 같은 장치가 필요 없다"고 적습니다. Granite-4.0-H-350M의 설정 파일에도 "position_embedding_type": "nope"가 있습니다. Mamba 층은 토큰을 순서대로 읽으니 순서가 이미 상태에 들어 있습니다. 저희가 짠 Jamba와 Granite 어텐션 코드에는 rope 호출이 없고, 두 모델 모두 실제 층과 맞았습니다.

잇는 방식

9. 병렬 블록: 어텐션과 FFN이 같은 입력을 읽습니다

왼쪽은 순차 연결인 GPT-2 블록으로, 어텐션 결과를 x에 더한 뒤 FFN이 바뀐 x를 읽습니다. 오른쪽은 Pythia가 만든 방식의 병렬 블록으로, 두 가지가 각자의 정규화를 거쳐 같은 x를 읽고 두 출력을 한 번에 더합니다. GPT-J와 PaLM은 같은 연결에 정규화 하나를 함께 씁니다.

보통 블록에서는 어텐션 결과가 더해진 x를 FFN이 받습니다. GPT-J(Wang and Komatsuzaki, 2021)는 둘을 같은 x에서 계산해 함께 더했습니다. PaLM(Chowdhery et al., 2022)은 이를 받아들이고 "MLP와 어텐션의 입력 행렬 곱을 합칠 수 있어 큰 규모에서 학습이 약 15% 빨라졌다"고 보고했습니다. 동시에 "80억 규모에서는 품질이 조금 떨어졌고 620억 규모에서는 떨어지지 않았다"고 적었으며, 5,400억 규모에서 영향이 없으리라는 것은 이 결과에서 미루어 본 것입니다. GPT-NeoX와 Pythia도 이 방식을 씁니다.

python
def parallel_block(x, sd, H, eps, theta, rot_frac):
    T, D = x.shape
    pos = torch.arange(T)
    h = layer_norm(x, sd["input_layernorm.weight"], sd["input_layernorm.bias"], eps)
    qkv = (h @ sd["attention.query_key_value.weight"].T + sd["attention.query_key_value.bias"])
    qkv = qkv.view(T, H, 3 * (D // H)).transpose(0, 1)              # 헤드마다 [q|k|v]
    q, k, v = qkv.chunk(3, -1)
    rd = int((D // H) * rot_frac)                                   # Pythia는 헤드 차원의 1/4만 돌립니다
    q, k = rope(q, pos, theta, rd), rope(k, pos, theta, rd)
    a = merge(attend(q, k, v, 1 / math.sqrt(D // H)))
    a = a @ sd["attention.dense.weight"].T + sd["attention.dense.bias"]
    h2 = layer_norm(x, sd["post_attention_layernorm.weight"], sd["post_attention_layernorm.bias"], eps)
    f = F.gelu(h2 @ sd["mlp.dense_h_to_4h.weight"].T + sd["mlp.dense_h_to_4h.bias"])
    f = f @ sd["mlp.dense_4h_to_h.weight"].T + sd["mlp.dense_4h_to_h.bias"]
    return x + a + f                                                # 한 번에 더하기

Pythia는 정규화를 하나로 공유하지 않고 두 개(h와 h2)를 따로 둡니다. GPT-NeoX 논문(Black et al., 2022)은 이것이 의도한 설계가 아니었고, 작은 규모 실험에서는 차이가 없었다고 밝힙니다. 대가: 한 층 안에서 FFN이 방금 어텐션이 찾은 정보를 쓸 수 없습니다.

FFN 칸

10. SwiGLU: 문(gate)이 달린 FFN

왼쪽은 GPT-2 FFN으로, 768에서 3,072로 올리고 GELU를 거쳐 768로 내립니다. 오른쪽은 Qwen3의 SwiGLU로, gate와 up 두 투영을 만들고, gate에 SiLU를 건 값과 up 투영을 원소별로 곱한 뒤 내립니다.

GPT-2의 FFN은 올리기, GELU, 내리기 세 단계입니다. 문이 달린 FFN(Shazeer, 2020)은 올리는 투영을 하나 더 만들고, 활성화를 거친 첫 투영과 원소별로 곱합니다.

python
def swiglu(h, sd, pre="mlp."):
    return (F.silu(h @ sd[pre + "gate_proj.weight"].T) * (h @ sd[pre + "up_proj.weight"].T)) @ sd[pre + "down_proj.weight"].T

논문이 보고한 것. 행렬이 하나 늘어난 만큼 안쪽 폭을 3,072에서 2,048로, 3분의 2로 줄여 매개변수와 계산량을 맞췄습니다. 그 조건에서 T5 방식 빈칸 채우기를 524,288스텝 학습한 뒤의 검증 로그 퍼플렉서티는 ReLU 1.677, GELU 1.679, SwiGLU 1.636, GEGLU 1.633이었습니다(낮을수록 좋습니다). 이유에 대한 저자의 설명은 이 두 문장이 전부입니다. "왜 이런 구조가 잘 되는지는 설명을 내놓지 못합니다. 다른 모든 것과 마찬가지로, 그 성공은 신의 은총 덕분으로 돌립니다." Qwen3는 SwiGLU를, Gemma는 GELU판인 GeGLU(위 sandwich_block)를 씁니다.

11. 전문가 혼합: 라우터가 FFN 몇 개를 고릅니다

왼쪽은 FFN 하나. 오른쪽은 Mixtral, Jamba의 전문가 혼합 FFN으로, 라우터가 전문가마다 점수를 매기고 상위 두 전문가만 계산하며 나머지는 건너뜁니다. 두 출력은 라우터 가중치로 더합니다.

전문가 혼합(MoE) 층은 FFN 하나를 여러 FFN(전문가)과 작은 라우터로 바꿉니다. 라우터가 토큰마다 전문가 몇 개를 고릅니다. Shazeer et al. (2017)은 LSTM 층 사이에 이를 넣었고, Switch Transformers(Fedus et al., 2021)는 트랜스포머 FFN 자리에 넣어 토큰마다 전문가 하나만 쓰게 했습니다. 이 논문은 "같은 계산 자원으로 사전 학습이 최대 7배 빨라졌다"고 보고합니다. Mixtral(Jiang et al., 2024)은 전문가 8개 중 2개를 고르며, 전체 매개변수 470억 개 중 토큰마다 130억 개를 씁니다.

python
def moe_ffn(h, sd, top_k):
    p = (h @ sd["feed_forward.router.weight"].T).softmax(-1)        # (토큰, 전문가)
    w, idx = p.topk(top_k, -1)                                       # Jamba는 고른 가중치를 다시 나누지 않습니다
    out = torch.zeros_like(h)
    gu, down = sd["feed_forward.experts.gate_up_proj"], sd["feed_forward.experts.down_proj"]
    for t in range(h.shape[0]):
        for j in range(top_k):
            e = idx[t, j]
            g, u = (h[t] @ gu[e].T).chunk(2, -1)
            out[t] += w[t, j] * ((F.silu(g) * u) @ down[e].T)
    return out, idx

이 함수는 어떤 전문가를 골랐는지도 돌려주니, 라우팅을 직접 볼 수 있습니다. 전문가 8개 중 2개를 고르는 Jamba-tiny-dev의 3번 층은 토큰 19개 중 10개를 0번 전문가에 보내고, 4번 전문가에는 1개만 보냅니다. 5번 층은 같은 토큰들을 다르게 나누며, 가장 많이 받은 전문가는 9개를 받은 3번입니다.

Jamba-tiny-dev의 MoE 층 두 개에서 문장의 토큰마다 전문가 8개 중 어느 2개를 썼는지 보여 주는 표. 행은 토큰 19개, 열은 전문가, 칠한 칸이 선택된 전문가입니다. 3번 층에서 전문가별로 받은 토큰 수는 10, 3, 7, 6, 1, 6, 3, 2이고, 5번 층은 2, 3, 5, 9, 5, 3, 6, 5입니다.

작은 개발용 모델에 문장 하나를 넣은 결과이니, 라우팅이 어떻게 생겼는지를 보여 줄 뿐 어느 전문가가 무엇을 맡는지는 말해 주지 않습니다. Mixtral이 밝힌 대가: 메모리는 쓰는 매개변수(130억)가 아니라 전체 매개변수(470억)만큼 필요하고, 라우팅에 따른 부담도 생깁니다. 그래서 MoE는 "여러 요청을 묶어 처리하는 작업에 더 알맞다"고 적습니다. Switch 논문은 "복잡도, 통신 비용, 학습 불안정"을 꼽습니다.

섞기 칸을 바꾸기

12. Mamba: 어텐션과 FFN 대신 칸 하나

왼쪽은 어텐션 가지와 FFN 가지가 있는 트랜스포머 층. 오른쪽은 Mamba 층으로, 정규화 뒤 x와 문 z로 투영하고, x에 짧은 합성곱을 건 뒤 크기가 고정된 상태로 선택적 스캔을 하고, z의 SiLU를 곱해 내립니다. 따로 된 FFN은 없습니다.

어텐션은 앞의 모든 토큰을 다시 보니 입력이 길어질수록 캐시가 커집니다. Mamba(Gu and Dao, 2023)는 그 대신 크기가 고정된 상태를 두고 토큰마다 한 번씩 갱신합니다. 갱신 방식이 토큰에 따라 달라지는 것이 "선택적"이라는 말의 뜻입니다. 걸음 크기 dt와 벡터 B, C를 입력에서 계산하므로, 모델이 토큰마다 무엇을 얼마나 남기고 무엇을 새로 쓸지 정할 수 있습니다. 원래 Mamba는 FFN도 없앴습니다. 저자들은 두 칸을 블록 하나로 합쳐 "같은 블록을 반복해 쌓았다"고 설명합니다.

아래는 Jamba의 Mamba 층을 순서대로 도는 스캔으로 쓴 것입니다.

python
def mamba1(h, sd, eps):
    T = h.shape[0]
    p = "mamba."
    xs, z = (h @ sd[p + "in_proj.weight"].T).chunk(2, -1)
    w = sd[p + "conv1d.weight"]
    xs = F.conv1d(xs.T[None], w, sd[p + "conv1d.bias"], padding=w.shape[-1] - 1, groups=w.shape[0])[0, :, :T].T
    xs = F.silu(xs)
    N, R = sd[p + "A_log"].shape[1], sd[p + "dt_proj.weight"].shape[1]
    dt, B, C = (xs @ sd[p + "x_proj.weight"].T).split([R, N, N], -1)
    dt, B, C = rms_norm(dt, sd[p + "dt_layernorm.weight"], eps), rms_norm(B, sd[p + "b_layernorm.weight"], eps), rms_norm(C, sd[p + "c_layernorm.weight"], eps)
    dt = F.softplus(dt @ sd[p + "dt_proj.weight"].T + sd[p + "dt_proj.bias"])   # 토큰마다 걸음 크기
    A = -torch.exp(sd[p + "A_log"])                                  # (채널, N)
    state = torch.zeros_like(A)
    ys = []
    for t in range(T):
        state = torch.exp(dt[t][:, None] * A) * state + (dt[t] * xs[t])[:, None] * B[t][None]
        ys.append(state @ C[t] + sd[p + "D"] * xs[t])
    return (torch.stack(ys) * F.silu(z)) @ sd[p + "out_proj.weight"].T

반복문 안의 한 줄에 핵심이 다 들어 있습니다. 이전 상태를 exp(dt * A)만큼 줄이고, 새 입력을 B로 써 넣고, C로 읽어 냅니다. dt, B, C에 거는 rms_norm 세 개는 Jamba가 더한 것이고 원래 Mamba에는 없습니다. Jamba는 Mamba 칸 뒤에 FFN이나 MoE 칸도 붙이므로(재현 묶음의 jamba_block), Jamba의 층은 Mamba 논문처럼 FFN이 없는 블록이 아닙니다.

논문이 보고한 것: 비슷한 크기의 트랜스포머보다 추론 처리량이 4-5배 높았고, 그 이유를 "KV 캐시가 없어 훨씬 큰 배치를 쓸 수 있기 때문"이라고 설명합니다. Mamba-3B는 두 배 크기의 트랜스포머와 성능이 비슷했습니다. 밝힌 한계: 평가가 작은 모델에 한정되어 있습니다. Jamba 논문은 한계를 하나 더 보탭니다. 순수 Mamba 모델은 예시 몇 개를 주는 프롬프트에서 "올바른 형식을 따르지 않는 경우가 많았고", 저자들은 이를 문맥 안 학습이 약하다는 신호로 봅니다.

13. Mamba-2: 같은 스캔을 더 단순하게, 헤드 단위로

왼쪽은 Mamba로, x와 z를 투영한 뒤 합성곱을 걸고, 그 x에서 dt, B, C를 계산하고, 채널과 상태마다 A 값을 둔 스캔을 합니다. 오른쪽은 Mamba-2로, x, z, B, C, dt를 처음 입력 투영 한 번에 모두 만들고, 스캔의 A는 헤드마다 숫자 하나이며, 출력 투영 앞에 정규화가 추가됩니다.

Mamba-2(Dao and Gu, 2024)는 블록을 세 군데 바꿉니다. B, C, dt를 합성곱 뒤의 x에서 계산하지 않고 입력 투영에서 바로 만듭니다. A를 채널마다 행렬로 두지 않고 헤드마다 숫자 하나로 두어, 스캔을 행렬 곱으로 계산할 수 있게 합니다. 그리고 "큰 모델에서 불안정이 생기기 쉬웠기 때문에" 출력 앞에 정규화를 넣습니다. 논문은 새 스캔이 Mamba의 스캔보다 2-8배 빠르고, 상태를 여덟 배 이상 키워도 느려지는 정도가 작다고 보고합니다.

Granite-4.0-H가 Mamba-2를 씁니다. 순수 Mamba와 달리 섞기 칸 뒤에 FFN이 있고, 두 번의 더하기 모두 0.246을 곱해 줄입니다. Granite는 앞 글에서 설명한 Mamba-2 함수로 확인했습니다.

python
h = rms_norm(x, sd[p + "input_layernorm.weight"], eps)
mix, _ = mamba2(sd, p, cfg, h)       # 어텐션 층 4개에서는 rope 호출 없는 어텐션
x2 = x + mix * cfg.residual_multiplier                                # 0.246
h2 = rms_norm(x2, sd[p + "post_attention_layernorm.weight"], eps)
g, u = (h2 @ sd[p + "shared_mlp.input_linear.weight"].T).chunk(2, -1)
out = x2 + (F.silu(g) * u) @ sd[p + "shared_mlp.output_linear.weight"].T * cfg.residual_multiplier

쌓는 방식

14. 하이브리드: 대부분 Mamba, 어텐션은 몇 층만

Mamba-2 논문이 직접 섞어 봤습니다. 매개변수 3억 5천만 개, 48층 모델에서 Pile 퍼플렉서티는 어텐션 층이 없을 때 8.60, 6개일 때 8.26, 트랜스포머는 8.68이었습니다(Table 2, 낮을수록 좋습니다). 저자들은 "전체 층의 약 10%를 어텐션으로 둘 때 가장 좋았다"고 적습니다. Jamba는 네 층에 하나와 여덟 층에 하나를 비교해 "성능 차이가 사실상 없다"는 결과를 얻었고, 여덟 층에 하나를 골랐습니다.

어느 층이 어떤 종류인지는 모델마다 설정 파일에 적혀 있어서, 설정 파일에서 바로 그렸습니다.

모델 일곱 개의 층을 한 칸씩, 첫 층을 왼쪽에 두고 그린 그림. GPT-2는 어텐션 12층, Qwen3-0.6B는 어텐션 28층입니다. Gemma-3-1B는 26층 중 여섯 층마다 하나가 전체 어텐션이고 나머지는 512토큰 슬라이딩 윈도 어텐션입니다. Jamba-v0.1은 32층 중 4, 12, 20, 28번이 어텐션이고 나머지는 Mamba이며 한 층 걸러 MoE입니다. Granite-4.0-H-350M은 32층 중 10, 13, 17, 27번이 어텐션입니다. Granite-4.0-H-Small은 40층 중 5, 15, 25, 35번이 어텐션이고 모든 층이 MoE입니다. Qwen3-Next-80B-A3B는 48층 중 네 층마다 하나가 전체 어텐션이고 나머지는 Gated DeltaNet이며 모든 층이 MoE입니다.

"하이브리드"라는 이름은 같아도 배치는 꽤 다릅니다. Jamba는 여덟 층마다 어텐션 하나를 규칙적으로 넣습니다. IBM은 Granite-4.0-H의 Micro, Tiny, Small을 Mamba-2와 어텐션을 "9:1 비율로" 섞었다고 설명합니다. 그런데 저희가 돌린 작은 350M 모델은 Mamba-2 28층에 어텐션 4층이고, 어텐션 층 간격도 고르지 않습니다. Qwen3-Next(모델 카드)는 Mamba를 아예 쓰지 않습니다. 네 층 중 세 층이 선형 어텐션의 한 형태인 Gated DeltaNet이고, 네 번째 층이 전체 어텐션입니다. 층마다 전문가가 512개 있고, 토큰마다 10개를 씁니다. Gemma 3는 이런 의미의 하이브리드는 아니지만 어텐션 안에서 같은 생각을 씁니다. 최근 512토큰만 보는 슬라이딩 윈도 층 다섯 개마다 전체 어텐션 층을 하나 둡니다.

얻는 것. 입력이 길어질 때 캐시가 커지는 층은 전체 어텐션 층뿐입니다. 저희는 설정 파일만 가지고 16비트 기준 시퀀스 하나의 캐시를 계산했습니다. 전체 어텐션 층마다 토큰당 2 × KV 헤드 수 × 헤드 크기 × 2바이트를 더하고, 슬라이딩 층은 512토큰까지만 같은 식으로 더하고, Mamba나 DeltaNet 층마다 고정 크기 상태를 더했습니다.

모델입력에 따라 커지는 층토큰당고정분4K 토큰128K 토큰
Qwen3-0.6B-Base28층 중 28층112 KiB0448 MiB14,336 MiB
Gemma-3-1B26층 중 4층(22층은 512토큰까지)4 KiB027 MiB523 MiB
Granite-4.0-H-350M32층 중 4층4 KiB10.8 MiB27 MiB523 MiB
Jamba-v0.132층 중 4층16 KiB8.3 MiB72 MiB2,056 MiB
Qwen3-Next-80B-A3B48층 중 12층24 KiB37.7 MiB134 MiB3,110 MiB

각 모델의 설정 파일에서 16비트 기준으로 계산한 값입니다. 모델 크기도 제각각이라 행끼리 비교하기보다 각 행을 그 모델의 어텐션 층 수와 같이 보시면 됩니다. 계산이 맞는지 확인할 수 있는 숫자가 하나 있습니다. 저희가 구한 Jamba-v0.1의 256K 토큰 캐시는 4,104 MiB이고, Jamba 논문 Table 1의 값은 4GB입니다.

치르는 것. 어텐션 층 몇 개는 남겨야 하고, 그 층들의 캐시는 여전히 커집니다. 앞 글에서 Granite의 어텐션 층 네 개를 꺼 봤습니다. 18토큰짜리 문장에서는(Alice가 13토큰 앞) 여전히 Alice라고 답했습니다(0.988). 같은 질문 사이에 상관없는 문단을 넣어 1,410토큰으로 늘리자 Alice의 확률이 0.002로 떨어졌고, 어텐션을 켠 원래 모델은 0.990을 유지했습니다. 저희 해석으로는 고정 크기 상태가 놓치는 정보를 몇 안 되는 어텐션 층이 맡습니다. 어텐션 층을 몇 개 남기고 어디에 둘지가 이 모델들이 서로 다르게 답하는 설계 문제입니다.

15. 한 층 안에서 섞기: Hymba

왼쪽은 Jamba, Granite처럼 층을 쌓아 섞는 하이브리드로, 층마다 섞기 칸이 Mamba나 어텐션 중 하나이고 뒤에 FFN이 있습니다. 오른쪽은 Hymba 층으로, 어텐션 헤드와 SSM 헤드가 같은 입력을 나란히 읽고, 두 출력을 각각 정규화하고 β를 곱한 뒤 더하고 FFN으로 갑니다.

NVIDIA의 Hymba(Dong et al., 2024)는 어텐션 헤드와 상태 공간(SSM) 헤드를 한 층 안에 나란히 두고 같은 입력을 읽게 합니다. SSM 출력이 "어텐션 헤드 출력보다 늘 컸기" 때문에, 두 출력을 각각 정규화하고 배율을 맞춘 뒤 합칩니다. 매개변수 3억 개를 1,000억 토큰으로 학습한 비교(Table 1)에서, 같은 부품을 층마다 번갈아 쌓은 구조 대비 이 병렬 구조의 상식 추론 정확도는 44.07%에서 45.19%로, 기억 회상은 45.16%에서 49.90%로 올랐습니다. Hymba는 대부분의 층에 슬라이딩 윈도 어텐션을 쓰고 전체 어텐션은 세 층에만 둡니다.

15가지 변화 한눈에 보기

#변화무엇을 바꿨나보고된 이득대가·한계
1Post-LN 블록(2017년 원조)영어-독일어 BLEU 28.4웜업이 필요함(Xiong 2020)
2디코더만인코더 + 디코더글 생성에 필요한 층만 남김(저희 요약)크로스 어텐션으로 읽을 원문 없음(저희 요약)
3Pre-LNPost-LN웜업 불필요, BERT 사전 학습 40% 단축밝힌 것 없음. 깊어질수록 본 흐름이 커짐(저희 측정)
4RMSNormLayerNorm스텝당 6.9% 빠름따로 밝힌 것 없음
5칸 앞뒤 정규화Pre-LN"학습 안정"수치 없음
6QK 정규화편향, 소프트 캡80억 규모 로짓 폭주 방지(ViT-22B)언어 모델 수치 없음
7RoPE학습한 위치 행BLEU 27.5 대 27.3잘 되는 이유는 설명 못 함
8NoPERoPE1억 700만 규모에서 긴 입력 일반화큰 규모 미검증
9병렬 블록순차 블록학습 약 15% 빠름80억 규모에서 품질 조금 하락
10SwiGLUReLU·GELU FFN로그 퍼플렉서티 1.636 대 1.677따로 밝힌 것 없음
11MoE FFNFFN 하나사전 학습 최대 7배 빠름메모리는 전문가 전체만큼
12Mamba어텐션 + FFN추론 처리량 4-5배예시 형식 따르기가 약함
13Mamba-2Mamba 스캔스캔 2-8배 빠름회상은 여전히 상태 크기에 묶임
14하이브리드 쌓기전부 어텐션 또는 전부 Mamba3억 5천만 규모 퍼플렉서티 8.26 대 8.60일부 층은 여전히 캐시가 커짐(저희 계산)
15한 층 안 하이브리드층 단위 하이브리드3억 규모 상식 추론 45.19 대 44.07밝힌 것 없음. 층마다 부품이 늘어남(저희 해석)

이득 칸과, "저희"라고 표시하지 않은 대가 칸은 모두 각 논문이 자기 설정에서 낸 내용입니다. 저희가 직접 돌린 것은 코드입니다. 코드는 모두 재현 묶음에 있고, 블록 함수마다 해당 모델의 층을 반올림 오차 안에서 재현합니다.

칸 하나를 직접 바꿔 보기

글 아래 재현 묶음의 verify.py는 일곱 모델을 Hugging Face에서 받아 층마다 들어간 값과 나온 값을 기록하고, blocks.py의 블록 함수와 비교합니다. CPU만으로 돌아갑니다. 블록 함수에서 한 줄을 바꿔 보는 것이 가장 쉬운 시작입니다. 예를 들어 GPT-2의 pre_ln_block에서 정규화를 더하기 뒤로 옮기면 Post-LN 블록이 되고, 실제 층 출력과의 차이가 얼마나 벌어지는지 바로 보입니다. 같은 방식으로 qwen3_block에서 RoPE를 빼 볼 수도 있습니다.

새 글이 올라올 때 받아 보시려면 아래 뉴스레터 폼에서 구독하실 수 있습니다.

이 글의 자료

재현 패키지

이 글의 하네스, 원 로그, 결과 CSV를 묶었습니다. 로그인 없이 받을 수 있고, GPU 없이 표의 숫자를 다시 계산하는 명령이 README에 있습니다.

block-variants-repro.zip · 33 KB

받기

더 많은 콘텐츠를 받아보세요

SNS에서 새로운 글과 튜토리얼 소식을 가장 먼저 받아보세요

이메일로 받아보기