๐Ÿค– LLM

MQA (Multi-Query Attention) ๋ถ„์„

MQA (Multi-Query Attention) โ€” ๊ณต์œ  KV ํ—ค๋“œ์™€ ๋””์ฝ”๋”ฉ ๋ฉ”๋ชจ๋ฆฌ ๋Œ€์—ญํญ ์ ˆ๊ฐ

Multi-Query Attention(MQA)์€ ์—ฌ๋Ÿฌ Query head๊ฐ€ ํ•˜๋‚˜์˜ Key head์™€ Value head๋ฅผ ๊ณต์œ ํ•˜๋Š” Attention ๋ณ€ํ˜•์ž…๋‹ˆ๋‹ค. Query head๋Š” ๊ทธ๋Œ€๋กœ ์œ ์ง€ํ•˜๋ฏ€๋กœ ์—ฌ๋Ÿฌ ํ‘œํ˜„ ๊ณต๊ฐ„์—์„œ ์ ์ˆ˜๋ฅผ ๊ณ„์‚ฐํ•  ์ˆ˜ ์žˆ์ง€๋งŒ, autoregressive decoding์—์„œ ๋ฐ˜๋ณตํ•ด์„œ ์ฝ๋Š” KV cache๋Š” ํ›จ์”ฌ ์ž‘์•„์ง‘๋‹ˆ๋‹ค. ๋”ฐ๋ผ์„œ MQA์˜ ์ฃผ๋œ ๋ชฉ์ ์€ ํ•™์Šต FLOPs๋ฅผ ์ค„์ด๋Š” ๊ฒƒ์ด ์•„๋‹ˆ๋ผ, ํ•œ ํ† ํฐ์”ฉ ์ƒ์„ฑํ•  ๋•Œ ๋ฐœ์ƒํ•˜๋Š” KV cache ๋ฉ”๋ชจ๋ฆฌ ๋Œ€์—ญํญ๊ณผ ์šฉ๋Ÿ‰์„ ์ค„์ด๋Š” ๊ฒƒ์ž…๋‹ˆ๋‹ค.

MQA๋Š” 2019๋…„ Shazeer์˜ Fast Transformer Decoding: One Write-Head is All You Need์—์„œ ์ œ์•ˆ๋˜์—ˆ์Šต๋‹ˆ๋‹ค. ์› ๋…ผ๋ฌธ์€ WMT14 English-German ์‹คํ—˜์—์„œ multi-head baseline์˜ decoder step ๋น„์šฉ 46 ยตs๊ฐ€ MQA์—์„œ 3.8 ยตs๋กœ ์ค„์–ด๋“œ๋Š” ๊ฒฐ๊ณผ๋ฅผ ๋ณด๊ณ ํ–ˆ์ง€๋งŒ, ์ด๋Š” TPUv2์™€ ๊ณ ์ •๋œ ์‹คํ—˜ ์กฐ๊ฑด์˜ ์ธก์ •๊ฐ’์ž…๋‹ˆ๋‹ค. ์ดํ›„ GQA๋Š” Query head์™€ KV head ์‚ฌ์ด์— ์ค‘๊ฐ„ ๊ฐœ์ˆ˜์˜ ๊ทธ๋ฃน์„ ๋‘์–ด MQA์˜ ์†๋„์™€ MHA์˜ ํ’ˆ์งˆ ์‚ฌ์ด๋ฅผ ์ ˆ์ถฉํ–ˆ์Šต๋‹ˆ๋‹ค.

ํ•ต์‹ฌ ๊ฐœ๋…

MHA, MQA, GQA์˜ head ๊ตฌ์„ฑ

์ผ๋ฐ˜์ ์ธ Multi-Head Attention(MHA)์€ ๊ฐ Query head์— ๋ณ„๋„์˜ K/V head๋ฅผ ๋‘ก๋‹ˆ๋‹ค. MQA๋Š” ๋ชจ๋“  Query head๊ฐ€ ํ•˜๋‚˜์˜ K/V head๋ฅผ ํ•จ๊ป˜ ์‚ฌ์šฉํ•ฉ๋‹ˆ๋‹ค. Grouped-Query Attention(GQA)์€ Query head๋ฅผ ์—ฌ๋Ÿฌ ๊ทธ๋ฃน์œผ๋กœ ๋ฌถ๊ณ , ๊ทธ๋ฃน๋งˆ๋‹ค ํ•˜๋‚˜์˜ K/V head๋ฅผ ๋ฐฐ์น˜ํ•ฉ๋‹ˆ๋‹ค.

MQA, GQA, MHA ๊ตฌ์กฐ ๋น„๊ต

๊ทธ๋ฆผ 1. Query head ์ˆ˜๋Š” ์œ ์ง€ํ•˜๋ฉด์„œ KV head ์ˆ˜๋งŒ ์ค„์ด๋Š” MQA/GQA์˜ ๊ตฌ์กฐ ๋น„๊ต

Hugging Face Transformers์˜ Llama ๊ณ„์—ด ์„ค์ •๋„ num_key_value_heads๋กœ ์ด ๊ตฌ๋ถ„์„ ํ‘œํ˜„ํ•ฉ๋‹ˆ๋‹ค.

  • num_key_value_heads = num_attention_heads: MHA
  • num_key_value_heads = 1: MQA
  • 1 < num_key_value_heads < num_attention_heads: GQA

๋”ฐ๋ผ์„œ MQA๋Š” Query๊นŒ์ง€ ํ•˜๋‚˜๋กœ ํ•ฉ์น˜๋Š” ๋ฐฉ์‹์ด ์•„๋‹™๋‹ˆ๋‹ค. Query๋Š” head๋ณ„๋กœ ๋…๋ฆฝ์ ์œผ๋กœ ์ƒ์„ฑ๋˜๋ฉฐ, K/V๋งŒ ๊ณต์œ ๋ฉ๋‹ˆ๋‹ค.

KV cache์˜ ํฌ๊ธฐ

๋ ˆ์ด์–ด ์ˆ˜๋ฅผ L, Query head ์ˆ˜๋ฅผ H, KV head ์ˆ˜๋ฅผ G, head dimension์„ D, ์‹œํ€€์Šค ๊ธธ์ด๋ฅผ T, ๋ฐฐ์น˜๋ฅผ B, KV ์ž๋ฃŒํ˜•์˜ ๋ฐ”์ดํŠธ ์ˆ˜๋ฅผ s๋ผ๊ณ  ํ•˜๋ฉด, ๋‹จ์ˆœํ•œ KV cache ์šฉ๋Ÿ‰์€ ๋‹ค์Œ๊ณผ ๊ฐ™์ด ๊ทผ์‚ฌํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

KV_bytes โ‰ˆ 2 ร— L ร— B ร— T ร— G ร— D ร— s

์•ž์˜ 2๋Š” Key์™€ Value๋ฅผ ํ•จ๊ป˜ ์ €์žฅํ•˜๊ธฐ ๋•Œ๋ฌธ์ž…๋‹ˆ๋‹ค. MHA์—์„œ๋Š” G=H, MQA์—์„œ๋Š” G=1, GQA์—์„œ๋Š” 1<G<H์ž…๋‹ˆ๋‹ค. ๊ฐ™์€ H, D, L, B, T, ์ž๋ฃŒํ˜•์ด๋ผ๋ฉด MQA์˜ KV ์šฉ๋Ÿ‰์€ MHA์˜ 1/H, GQA๋Š” G/H ์ˆ˜์ค€์ž…๋‹ˆ๋‹ค. ์‹ค์ œ ๊ตฌํ˜„์—์„œ๋Š” tensor parallelism์˜ shard, padding, block allocator, scale ๋ฉ”ํƒ€๋ฐ์ดํ„ฐ๊ฐ€ ์ถ”๊ฐ€๋˜๋ฏ€๋กœ ์ด ์‹์€ ๊ตฌ์กฐ์ ์ธ ๋น„๊ต์šฉ์œผ๋กœ ๋ณด๋Š” ๊ฒƒ์ด ์•ˆ์ „ํ•ฉ๋‹ˆ๋‹ค.

์™œ decoding์—์„œ ํŠนํžˆ ํšจ๊ณผ์ ์ธ๊ฐ€

Prefill์€ ์—ฌ๋Ÿฌ ์œ„์น˜์˜ Query๋ฅผ ๋ณ‘๋ ฌ๋กœ ์ฒ˜๋ฆฌํ•  ์ˆ˜ ์žˆ์–ด GEMM์˜ ๊ณ„์‚ฐ๋Ÿ‰๊ณผ GPU ํ™œ์šฉ๋ฅ ์ด ์ค‘์š”ํ•ฉ๋‹ˆ๋‹ค. ๋ฐ˜๋ฉด decode๋Š” ๋ณดํ†ต ์ƒˆ Query ํ•œ ๊ฐœ๋งŒ ์ถ”๊ฐ€ํ•˜๊ณ  ๊ณผ๊ฑฐ ์ „์ฒด K/V๋ฅผ ๋‹ค์‹œ ์ฝ์Šต๋‹ˆ๋‹ค. ์ด๋•Œ ์—ฐ์‚ฐ๋Ÿ‰๋ณด๋‹ค HBM์—์„œ KV๋ฅผ ๊ฐ€์ ธ์˜ค๋Š” ๋น„์šฉ์ด ๋ณ‘๋ชฉ์ด ๋˜๊ธฐ ์‰ฌ์šฐ๋ฏ€๋กœ, KV head ์ˆ˜๋ฅผ ์ค„์ด๋Š” MQA์˜ ํšจ๊ณผ๊ฐ€ ์ปค์ง‘๋‹ˆ๋‹ค.

MQA๋Š” ๋‹ค์Œ ๋„ค ๊ฐ€์ง€๋ฅผ ๋™์‹œ์— ์ค„์ž…๋‹ˆ๋‹ค.

  • KV cache์˜ ์ €์žฅ ์šฉ๋Ÿ‰
  • ๋งค decoding step์—์„œ ์ฝ์–ด์•ผ ํ•˜๋Š” K/V ๋ฐ์ดํ„ฐ๋Ÿ‰
  • K/V projection ๊ฒฐ๊ณผ์˜ ์ €์žฅยท์ด๋™๋Ÿ‰
  • ๋Œ€๊ทœ๋ชจ ๋ฐฐ์น˜์—์„œ ์š”์ฒญ ํ•˜๋‚˜๊ฐ€ ์ฐจ์ง€ํ•˜๋Š” ๋ฉ”๋ชจ๋ฆฌ ๋ฐœ์ž๊ตญ

๋ฐ˜๋ฉด Query projection, attention score ๊ณ„์‚ฐ์˜ Query head ์ˆ˜, output projection์€ ๊ธฐ๋ณธ์ ์œผ๋กœ ์œ ์ง€๋ฉ๋‹ˆ๋‹ค. ๋”ฐ๋ผ์„œ MQA๋ฅผ "Attention ์ „์ฒด๊ฐ€ 1๊ฐœ head๊ฐ€ ๋˜๋Š” ๊ธฐ๋ฒ•"์œผ๋กœ ์ดํ•ดํ•˜๋ฉด ์•ˆ ๋ฉ๋‹ˆ๋‹ค.

๋น„๊ต/๋ถ„์„

ํ•ญ๋ชฉ MHA GQA MQA
Query head ์ˆ˜ H H H
KV head ์ˆ˜ H G, 1<G<H 1
KV cache ๋น„์œจ(MHA=1) 1 G/H 1/H
head๋ณ„ K/V ํ‘œํ˜„ ์™„์ „ํžˆ ๋…๋ฆฝ ๊ทธ๋ฃน ๋‚ด๋ถ€ ๊ณต์œ  ์ „์ฒด Query๊ฐ€ ๊ณต์œ 
decoding ๋Œ€์—ญํญ ๊ฐ€์žฅ ํผ ์ค‘๊ฐ„ ๊ฐ€์žฅ ์ž‘์Œ
ํ’ˆ์งˆยทํŠœ๋‹ ์œ„ํ—˜ ๊ธฐ์ค€์„  MQA๋ณด๋‹ค ๋‚ฎ์Œ ์ƒ๋Œ€์ ์œผ๋กœ ํผ
๊ธฐ์กด MHA checkpoint ๋ณ€ํ™˜ ํ•ด๋‹น ์—†์Œ uptraining ๋˜๋Š” ์žฌํ•™์Šต uptraining ๋˜๋Š” ์žฌํ•™์Šต

๊ฐ„๋‹จํ•œ ์˜ˆ

H=32, D=128, FP16(s=2)์ธ ํ•œ ๋ ˆ์ด์–ด์—์„œ ํ† ํฐ ํ•˜๋‚˜์˜ K/V ์ €์žฅ๋Ÿ‰์€ ๋‹ค์Œ๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค.

๊ตฌ์„ฑ KV head ์ˆ˜ ํ† ํฐ๋‹น K/V ์›์†Œ FP16 ์ €์žฅ๋Ÿ‰
MHA 32 2 ร— 32 ร— 128 16 KiB
GQA-8 8 2 ร— 8 ร— 128 4 KiB
MQA 1 2 ร— 1 ร— 128 0.5 KiB

์ด๋Š” ํ•œ ๋ ˆ์ด์–ดยทํ•œ ํ† ํฐ๋งŒ์˜ ๊ฐ’์ž…๋‹ˆ๋‹ค. 32๊ฐœ ๋ ˆ์ด์–ด, ๊ธด ๋ฌธ๋งฅ, ์—ฌ๋Ÿฌ ์š”์ฒญ์ด ๊ฒน์น˜๋ฉด ์ฐจ์ด๊ฐ€ ๋ˆ„์ ๋ฉ๋‹ˆ๋‹ค. ๋‹ค๋งŒ KV head๋ฅผ ์ค„์˜€๋‹ค๊ณ  ํ•ด์„œ Query head์— ํ•„์š”ํ•œ ์—ฐ์‚ฐ๊ณผ ๋ชจ๋ธ ๊ฐ€์ค‘์น˜ ์ „์ฒด๊ฐ€ ๊ฐ™์€ ๋น„์œจ๋กœ ์ค„์–ด๋“œ๋Š” ๊ฒƒ์€ ์•„๋‹™๋‹ˆ๋‹ค.

์ •ํ™•๋„์™€ ์†๋„์˜ ์ ˆ์ถฉ

KV๋ฅผ ๊ณต์œ ํ•˜๋ฉด ๊ฐ head๊ฐ€ ์„œ๋กœ ๋‹ค๋ฅธ K/V projection์„ ์‚ฌ์šฉํ•˜๋˜ ์ž์œ ๋„๊ฐ€ ์‚ฌ๋ผ์ง‘๋‹ˆ๋‹ค. ์› ๋…ผ๋ฌธ์€ MQA๊ฐ€ baseline๋ณด๋‹ค ์•ฝ๊ฐ„ ๋‚ฎ์€ ํ’ˆ์งˆ์„ ๋ณด์ด์ง€๋งŒ ๋Œ€์ฒด๋กœ ๋น„์Šทํ•œ ์ˆ˜์ค€์ด๋ผ๊ณ  ๋ณด๊ณ ํ–ˆ์Šต๋‹ˆ๋‹ค. ์ดํ›„ GQA ๋…ผ๋ฌธ์€ ๊ธฐ์กด MHA checkpoint๋ฅผ ํ‰๊ท  pooling ๋“ฑ์œผ๋กœ KV head๋ฅผ ์ค„์ธ ๋’ค ์›๋ž˜ pre-training compute์˜ 5%๋ฅผ ์‚ฌ์šฉํ•˜๋Š” uptraining์œผ๋กœ ํ’ˆ์งˆ์„ ํšŒ๋ณตํ•˜๋Š” ๋ฐฉ๋ฒ•์„ ์ œ์‹œํ–ˆ๊ณ , ์ค‘๊ฐ„ ๊ฐœ์ˆ˜์˜ KV head๊ฐ€ MQA์— ๊ฐ€๊นŒ์šด ์†๋„์™€ MHA์— ๊ฐ€๊นŒ์šด ํ’ˆ์งˆ์„ ์ œ๊ณตํ•œ๋‹ค๊ณ  ๋ณด๊ณ ํ–ˆ์Šต๋‹ˆ๋‹ค.

๋™์ž‘ ์›๋ฆฌ

1. Projection ๋‹จ๊ณ„

์ž…๋ ฅ hidden state X์—์„œ Query๋Š” H๊ฐœ head๋กœ ํˆฌ์˜ํ•˜๊ณ , Key์™€ Value๋Š” G๊ฐœ head๋กœ ํˆฌ์˜ํ•ฉ๋‹ˆ๋‹ค. MQA์—์„œ๋Š” G=1์ด๋ฏ€๋กœ K/V projection์˜ ์ถœ๋ ฅ shape๊ฐ€ Query projection๋ณด๋‹ค ์ž‘์Šต๋‹ˆ๋‹ค.

Q = X ยท Wq       -> [B, H, T, D]
K = X ยท Wk       -> [B, G, T, D]
V = X ยท Wv       -> [B, G, T, D]

MHA์˜ ๊ฒฝ์šฐ G=H์ด๊ณ , MQA์˜ ๊ฒฝ์šฐ G=1์ž…๋‹ˆ๋‹ค. GQA์—์„œ๋Š” ๊ฐ Query head๊ฐ€ H/G๊ฐœ์˜ Query group ์ค‘ ํ•˜๋‚˜์— ์†ํ•ฉ๋‹ˆ๋‹ค. H๊ฐ€ G๋กœ ๋‚˜๋ˆ„์–ด ๋–จ์–ด์ง€๋Š” ์„ค์ •์ด ์ผ๋ฐ˜์ ์ด์ง€๋งŒ, ์‹ค์ œ ํ”„๋ ˆ์ž„์›Œํฌ๋Š” ๋ชจ๋ธ ์„ค์ •์˜ ์ œ์•ฝ์„ ๋ณ„๋„๋กœ ๊ฒ€์‚ฌํ•ฉ๋‹ˆ๋‹ค.

2. Attention์—์„œ K/V broadcast

๊ฐ Query head๋Š” ์ž์‹ ์ด ์†ํ•œ KV group์˜ K์™€ V๋ฅผ ์‚ฌ์šฉํ•ฉ๋‹ˆ๋‹ค. ๋…ผ๋ฆฌ์ ์œผ๋กœ๋Š” K/V๋ฅผ Query head ์ˆ˜์— ๋งž์ถฐ broadcast ๋˜๋Š” repeatํ•œ ๊ฒƒ๊ณผ ๊ฐ™์ง€๋งŒ, ํšจ์œจ์ ์ธ ์ปค๋„์€ ์‹ค์ œ๋กœ ๋™์ผํ•œ K/V๋ฅผ ๋งค๋ฒˆ ๋ณต์ œํ•˜์ง€ ์•Š๊ณ  group index๋กœ ์ฐธ์กฐํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

MQA decode์™€ KV cache ํ๋ฆ„

๊ทธ๋ฆผ 2. ํ•œ ํ† ํฐ decode์—์„œ Query๋Š” H๊ฐœ๋ฅผ ์œ ์ง€ํ•˜๊ณ  K/V cache๋Š” G๊ฐœ๋งŒ ์ฝ๋Š” ํ๋ฆ„

group(h) = floor(h / (H / G))
score[h] = softmax(Q[h] ยท K[group(h)]^T / sqrt(D))
O[h]     = score[h] ยท V[group(h)]
Y        = concat(O[0], ..., O[H-1]) ยท Wo

MQA์—์„œ๋Š” ๋ชจ๋“  h์— ๋Œ€ํ•ด group(h)=0์ž…๋‹ˆ๋‹ค. ์ฆ‰, score vector๋Š” head๋ณ„๋กœ ๋‹ค๋ฅด์ง€๋งŒ ๋ชจ๋“  head๊ฐ€ ๊ฐ™์€ K/V sequence๋ฅผ ์กฐํšŒํ•ฉ๋‹ˆ๋‹ค. ์ด ์ฐจ์ด ๋•Œ๋ฌธ์— MQA๋Š” ํ•˜๋‚˜์˜ Attention ๊ฒฐ๊ณผ๋ฅผ ๋ชจ๋“  head์— ๋ณต์‚ฌํ•˜๋Š” ๊ฒƒ์ด ์•„๋‹™๋‹ˆ๋‹ค.

3. Incremental decoding๊ณผ cache append

์ƒˆ ํ† ํฐ์˜ hidden state x_t๊ฐ€ ๋“ค์–ด์˜ค๋ฉด ๊ฐ ๋ ˆ์ด์–ด๋Š” ์ƒˆ q_t๋ฅผ H๊ฐœ ๋งŒ๋“ค๊ณ , ์ƒˆ k_t, v_t๋Š” G๊ฐœ๋งŒ ๋งŒ๋“ญ๋‹ˆ๋‹ค. ์ƒˆ K/V๋Š” cache์˜ ๋งˆ์ง€๋ง‰ ์œ„์น˜์— ์ถ”๊ฐ€๋˜๊ณ , ํ˜„์žฌ Query๋Š” ์ด์ „ ๋ชจ๋“  ์œ„์น˜์˜ K/V์™€ attention์„ ์ˆ˜ํ–‰ํ•ฉ๋‹ˆ๋‹ค.

for each layer:
    q_t = project_query(x_t)          # H heads
    k_t = project_key(x_t)            # G heads
    v_t = project_value(x_t)          # G heads
    append(K_cache, k_t)
    append(V_cache, v_t)

    for h in query_heads:
        g = h // (H / G)
        a_h = softmax(q_t[h] @ K_cache[g].T / sqrt(D))
        o_h = a_h @ V_cache[g]

์ด ๊ฒฝ๋กœ์—์„œ ๋งค step ์ฝ๋Š” cache์˜ ๊ธธ์ด T๋Š” ๊ฐ™์ง€๋งŒ head ์ˆ˜ G๊ฐ€ ์ค„์–ด๋“ญ๋‹ˆ๋‹ค. ๊ทธ๋ž˜์„œ ๊ธด ๋ฌธ๋งฅ์ด๋‚˜ ํฐ batch์—์„œ HBM read pressure๊ฐ€ ์ค„๊ณ , ๊ฐ™์€ GPU ๋ฉ”๋ชจ๋ฆฌ๋กœ ๋” ๋งŽ์€ sequence๋ฅผ ์ˆ˜์šฉํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

4. Tensor parallelism ์ฃผ์˜์ 

์—ฌ๋Ÿฌ GPU์— ๋ชจ๋ธ์„ tensor parallel๋กœ ๋‚˜๋ˆŒ ๋•Œ๋Š” Query head์™€ KV head์˜ ๋ฐฐ์น˜๊ฐ€ ํ†ต์‹ ๋Ÿ‰์— ์˜ํ–ฅ์„ ์ค๋‹ˆ๋‹ค. KV head๊ฐ€ ๋„ˆ๋ฌด ์ ์œผ๋ฉด ๊ฐ shard์— KV head๋ฅผ ๊ท ๋“ฑํ•˜๊ฒŒ ๋ฐฐ์น˜ํ•˜๊ธฐ ์–ด๋ ต๊ฑฐ๋‚˜, attention ์ „์— KV๋ฅผ broadcastํ•˜๋Š” ํ†ต์‹ ์ด ํ•„์š”ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ๋”ฐ๋ผ์„œ ์ด๋ก ์ ์ธ H/G ๋ฉ”๋ชจ๋ฆฌ ์ ˆ๊ฐ์ด ๊ทธ๋Œ€๋กœ end-to-end latency ํ–ฅ์ƒ์œผ๋กœ ์ด์–ด์ง€๋Š”์ง€๋Š” GPU ์ˆ˜, head ๋ฐฐ์น˜, fused attention kernel, interconnect์— ๋”ฐ๋ผ ๋‹ฌ๋ผ์ง‘๋‹ˆ๋‹ค.

์žฅ๋‹จ์ 

์žฅ์ 

  • KV head ์ˆ˜๋ฅผ ์ค„์—ฌ KV cache ์šฉ๋Ÿ‰๊ณผ ๋งค decode step์˜ ๋ฉ”๋ชจ๋ฆฌ ์ฝ๊ธฐ๋Ÿ‰์„ ์ง์ ‘ ์ค„์ž…๋‹ˆ๋‹ค.
  • Query head ์ˆ˜๋ฅผ ์œ ์ง€ํ•˜๋ฏ€๋กœ ๋‹จ์ˆœํžˆ ์ „์ฒด Attention์„ ์ €์ฐจ์›์œผ๋กœ ์ถ•์†Œํ•˜๋Š” ๊ฒƒ๋ณด๋‹ค ํ‘œํ˜„๋ ฅ์„ ๋ณด์กดํ•ฉ๋‹ˆ๋‹ค.
  • ๊ธด context, ํฐ batch, beam search์™€ ๊ฐ™์ด KV cache๊ฐ€ ์ปค์ง€๋Š” serving workload์— ํŠนํžˆ ์œ ๋ฆฌํ•ฉ๋‹ˆ๋‹ค.
  • GQA๋ผ๋Š” ์ค‘๊ฐ„ ์ง€์ ์„ ํ†ตํ•ด ํ’ˆ์งˆ๊ณผ ๋ฉ”๋ชจ๋ฆฌ ๋Œ€์—ญํญ ์‚ฌ์ด๋ฅผ ๋ชจ๋ธ๋ณ„๋กœ ์กฐ์ •ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.
  • PagedAttention, continuous batching, KV cache quantization๊ณผ ์ง๊ต์ ์œผ๋กœ ๊ฒฐํ•ฉํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. MQA๋Š” head ์ฐจ์›, PagedAttention์€ ๋ฐฐ์น˜ยทํ† ํฐ์˜ ๋ฐฐ์น˜ ๋ฐฉ์‹, quantization์€ ์›์†Œ ์ •๋ฐ€๋„๋ฅผ ์ค„์ด๋Š” ๊ธฐ๋ฒ•์ž…๋‹ˆ๋‹ค.

๋‹จ์ 

  • ๋ชจ๋“  Query head๊ฐ€ ๊ฐ™์€ K/V ํ‘œํ˜„์„ ๊ณต์œ ํ•˜๋ฏ€๋กœ MHA ๋Œ€๋น„ ํ’ˆ์งˆ ์ €ํ•˜๊ฐ€ ์ƒ๊ธธ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.
  • ๊ธฐ์กด MHA checkpoint๋ฅผ ๋‹จ์ˆœํžˆ ์ž˜๋ผ์„œ MQA๋กœ ๋ฐ”๊พธ๋ฉด ๋ถ„ํฌ๊ฐ€ ๋‹ฌ๋ผ์ง‘๋‹ˆ๋‹ค. mean pooling ๊ธฐ๋ฐ˜ uptraining์ด๋‚˜ ๋ณ„๋„ ์žฌํ•™์Šต์ด ํ•„์š”ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.
  • KV head๊ฐ€ 1๊ฐœ๋ผ์„œ GPUยทtensor parallel shard์— ๊ท ๋“ฑํ•˜๊ฒŒ ๋ฐฐ์น˜ํ•˜๊ธฐ ์–ด๋ ต๊ณ , ๊ตฌํ˜„์— ๋”ฐ๋ผ broadcast ํ†ต์‹ ์ด ์ƒ๊ธธ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.
  • Prefill์—์„œ๋Š” decode๋งŒํผ KV read bandwidth๊ฐ€ ์ง€๋ฐฐ์ ์ด์ง€ ์•Š์„ ์ˆ˜ ์žˆ์–ด, MQA์˜ ํšจ๊ณผ๊ฐ€ workload ์ „์ฒด์—์„œ ๋™์ผํ•˜์ง€ ์•Š์Šต๋‹ˆ๋‹ค.
  • Query ๊ณ„์‚ฐ๊ณผ output projection์€ ํฌ๊ฒŒ ์ค„์ง€ ์•Š์œผ๋ฏ€๋กœ, MQA๋ฅผ ์ ์šฉํ•ด๋„ compute-bound workload์˜ ์†๋„๊ฐ€ ๊ฐ™์€ ๋น„์œจ๋กœ ๊ฐœ์„ ๋˜์ง€๋Š” ์•Š์Šต๋‹ˆ๋‹ค.

๊ด€๋ จ ๊ธฐ์ˆ  ๋ฐ ์ฐธ๊ณ  ๋ฌธํ—Œ

๋ฌธ์„œ/์—ฐ๊ตฌ ์—ฐ๊ฒฐ์ 
LLM Basics Transformer decoder, prefill/decode, KV cache์˜ ๊ธฐ๋ณธ ๊ฐœ๋…
PagedAttention Analysis KV cache๋ฅผ ๋ธ”๋ก์œผ๋กœ ๋ฐฐ์น˜ํ•˜๋Š” ๋ฉ”๋ชจ๋ฆฌ ๊ด€๋ฆฌ
KV Cache Quantization Analysis KV ์›์†Œ์˜ FP16/FP8/INT8/์ €๋น„ํŠธ ํ‘œํ˜„
MLA Analysis KV๋ฅผ latent representation์œผ๋กœ ์••์ถ•ํ•˜๋Š” ๋‹ค๋ฅธ ๊ตฌ์กฐ์  ์ ‘๊ทผ
Shazeer, Fast Transformer Decoding: One Write-Head is All You Need, arXiv:1911.02150 MQA ์ œ์•ˆ๊ณผ incremental decoding ๋น„์šฉ ๋ถ„์„
Ainslie et al., GQA: Training Generalized Multi-Query Transformer Models from Multi-Head Checkpoints, EMNLP 2023, arXiv:2305.13245 GQA์™€ MHA checkpoint uptraining
Hugging Face Transformers LlamaConfig ๋ฌธ์„œ num_key_value_heads๋ฅผ ํ†ตํ•œ MHA/GQA/MQA ์„ค์ • ์ •์˜

๊ตฌํ˜„ ์‹œ ํ™•์ธํ•  ํ•ญ๋ชฉ

  • ๋ชจ๋ธ config์˜ num_attention_heads, num_key_value_heads, head_dim์ด ์„œ๋กœ ์ผ๊ด€์ ์ธ์ง€ ํ™•์ธํ•ฉ๋‹ˆ๋‹ค.
  • KV cache shape๊ฐ€ [batch, kv_heads, sequence, head_dim]์ธ์ง€, backend๊ฐ€ ์š”๊ตฌํ•˜๋Š” layout์ธ์ง€ ํ™•์ธํ•ฉ๋‹ˆ๋‹ค.
  • GQA/MQA์˜ KV repeat๊ฐ€ ์‹ค์ œ ๋ณต์ œ์ธ์ง€, attention kernel ๋‚ด๋ถ€์˜ ๋…ผ๋ฆฌ์  broadcast์ธ์ง€ ํ™•์ธํ•ฉ๋‹ˆ๋‹ค.
  • MQA์™€ quantized cache๋ฅผ ํ•จ๊ป˜ ์‚ฌ์šฉํ•  ๋•Œ scale์˜ ์ถ•๊ณผ KV group mapping์ด ์ผ์น˜ํ•˜๋Š”์ง€ ํ™•์ธํ•ฉ๋‹ˆ๋‹ค.
  • ํ’ˆ์งˆ์€ perplexity๋งŒ ๋ณด์ง€ ๋ง๊ณ  long-context retrieval, instruction following, reasoning ๋“ฑ ์‹ค์ œ workload์—์„œ ์ธก์ •ํ•ฉ๋‹ˆ๋‹ค.

ํ•ต์‹ฌ ์ •๋ฆฌ

MQA๋Š” H๊ฐœ์˜ Query head๋ฅผ ์œ ์ง€ํ•˜๋ฉด์„œ K/V head๋ฅผ 1๊ฐœ๋กœ ๊ณต์œ ํ•ด KV cache์˜ ์šฉ๋Ÿ‰๊ณผ decoding ๋ฉ”๋ชจ๋ฆฌ ๋Œ€์—ญํญ์„ ์ค„์ด๋Š” Attention ๊ตฌ์กฐ์ž…๋‹ˆ๋‹ค. KV cache ์šฉ๋Ÿ‰์€ KV head ์ˆ˜ G์— ๋น„๋ก€ํ•˜๋ฏ€๋กœ MHA ๋Œ€๋น„ GQA๋Š” G/H, MQA๋Š” 1/H ์ˆ˜์ค€์œผ๋กœ ์ค„์–ด๋“ค ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ๋Œ€์‹  K/V ํ‘œํ˜„์„ ๊ณต์œ ํ•˜๋Š” ๋Œ€๊ฐ€๋กœ ํ’ˆ์งˆ ์ €ํ•˜์™€ tensor parallel ๋ฐฐ์น˜ ์ œ์•ฝ์ด ์ƒ๊ธธ ์ˆ˜ ์žˆ์–ด, ๊ธฐ์กด checkpoint์—๋Š” uptraining์ด๋‚˜ GQA๊ฐ€ ์‹ค์šฉ์ ์ธ ์ ˆ์ถฉ์ด ๋ฉ๋‹ˆ๋‹ค. PagedAttention๊ณผ quantization์ด ๊ฐ๊ฐ ๋ฐฐ์น˜ ๋ฐฉ์‹๊ณผ ์›์†Œ ์ •๋ฐ€๋„๋ฅผ ์ค„์ด๋Š” ๊ฒƒ๊ณผ ๋‹ฌ๋ฆฌ, MQA๋Š” Attention์˜ head ์ฐจ์›์„ ์ค„์ด๋Š” ๊ธฐ๋ฒ•์ด๋ฉฐ ์„ธ ๊ฐ€์ง€๋ฅผ ํ•จ๊ป˜ ์ ์šฉํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

์ฃผ์˜ โ€” ์› ๋…ผ๋ฌธ์˜ 46 ยตsโ†’3.8 ยตs ์ˆ˜์น˜๋Š” WMT14 English-German, TPUv2, ํŠน์ • batch์™€ sequence length์˜ incremental decoding ์ธก์ •๊ฐ’์ž…๋‹ˆ๋‹ค. ์‹ค์ œ ์ด๋“์€ ๋ชจ๋ธ์˜ H/G, context length, batch size, attention kernel, tensor parallelism, interconnect์™€ prefill/decode ๋น„์œจ์— ๋”ฐ๋ผ ๋‹ฌ๋ผ์ง‘๋‹ˆ๋‹ค.