GQA (Grouped-Query Attention) ๋ถ์
GQA โ MHA์ MQA ์ฌ์ด์ KV ํค๋ ์ค๊ณ
Grouped-Query Attention(GQA)์ Query head๋ ์ฌ๋ฌ ๊ฐ ์ ์งํ๋ฉด์ Key/Value head๋ง ์ค์ด๊ณ , ์ฌ๋ฌ Query head๊ฐ ํ๋์ KV head๋ฅผ ๊ณต์ ํ๋ Attention ๊ตฌ์กฐ์ ๋๋ค. Multi-Head Attention(MHA)์ ํํ๋ ฅ๊ณผ Multi-Query Attention(MQA)์ ์์ KV cache ์ฌ์ด์ ์ค๊ฐ ์ง์ ์ ๋ก๋๋ค.
GQA์ ์ง์ ์ ์ธ ๋ชฉ์ ์ ๋ชจ๋ธ ์ ์ฒด ํ๋ผ๋ฏธํฐ๋ฅผ ํฌ๊ฒ ์ค์ด๋ ๊ฒ์ด ์๋๋ผ autoregressive decoding์์ ๋ฐ๋ณตํด์ ์ฝ๋ KV cache์ ์ฉ๋๊ณผ ๋ฉ๋ชจ๋ฆฌ ๋์ญํญ์ ๋ฎ์ถ๋ ๊ฒ์ ๋๋ค. Ainslie et al.์ ๊ธฐ์กด MHA checkpoint๋ฅผ ๊ทธ๋ฃนํ๋ ๊ตฌ์กฐ๋ก ๋ฐ๊พผ ๋ค ์๋ ์ฌ์ ํ์ต ๊ณ์ฐ๋์ ์ฝ 5%๋ฅผ ์ฌ์ฉํ๋ uptraining recipe๋ฅผ ์ ์ํ๊ณ , GQA๊ฐ MQA์ ๊ฐ๊น์ด ์๋์ MHA์ ๊ฐ๊น์ด ํ์ง์ ์ ๊ณตํ ์ ์์์ ๋ณด์์ต๋๋ค.
๊ทธ๋ฆผ 1. Query head ์๋ ์ ์งํ๊ณ KV head ์๋ง H์์ G๋ก ์ค์ด๋ ๊ตฌ์กฐ
ํต์ฌ ๊ฐ๋
Query head์ KV head์ ๋ถ๋ฆฌ
Query head ์๋ฅผ H, Key/Value head ์๋ฅผ G๋ผ๊ณ ํ๋ฉด ์ธ ๊ตฌ์กฐ๋ ๋ค์์ฒ๋ผ ํํํ ์ ์์ต๋๋ค.
| ๊ตฌ์กฐ | Query head ์ | KV head ์ | ๊ทธ๋ฃน๋น Query head ์ |
|---|---|---|---|
| MHA | H |
H |
1 |
| GQA | H |
G, 1 < G < H |
H/G |
| MQA | H |
1 | H |
Hugging Face Transformers์ Llama ๊ณ์ด ์ค์ ์์๋ num_attention_heads=H, num_key_value_heads=G๋ก ์ด ๊ตฌ๋ถ์ ๋ํ๋
๋๋ค. G=H์ด๋ฉด MHA, G=1์ด๋ฉด MQA, ๊ทธ ์ฌ์ด๋ฉด GQA์
๋๋ค. ์ผ๋ฐ์ ์ธ ๊ตฌํ์ H๊ฐ G๋ก ๋๋์ด๋จ์ด์ง๋๋ก ๋ชจ๋ธ์ ๊ตฌ์ฑํ์ฌ ๊ฐ KV head๊ฐ ๊ฐ์ ์์ Query head๋ฅผ ๋ด๋นํ๊ฒ ํฉ๋๋ค.
KV cache ์ฉ๋
๋ ์ด์ด ์๋ฅผ L, ๋ฐฐ์น๋ฅผ B, ๋ฌธ๋งฅ ๊ธธ์ด๋ฅผ T, head dimension์ D, KV ์์ ํ๋์ ๋ฐ์ดํธ ์๋ฅผ s๋ผ๊ณ ํ๋ฉด KV cache์ ๊ตฌ์กฐ์ ์ฉ๋์ ๋ค์๊ณผ ๊ฐ์ด ๊ทผ์ฌํ ์ ์์ต๋๋ค.
KV_bytes โ 2 ร L ร B ร T ร G ร D ร s
์์ 2๋ Key์ Value๋ฅผ ํจ๊ป ์ ์ฅํ๋ค๋ ๋ป์
๋๋ค. ๊ฐ์ L, B, T, D, ์๋ฃํ์ ์ ์งํ๋ฉด GQA์ cache๋ MHA ๋๋น G/H ๋น์จ์
๋๋ค. ์๋ฅผ ๋ค์ด H=32, G=8์ธ GQA-8์ head ์ฐจ์๋ง์ผ๋ก KV cache๋ฅผ 1/4๋ก ์ค์
๋๋ค. ์ค์ ์ฌ์ฉ๋์๋ block allocator, padding, scale metadata, tensor-parallel shard๊ฐ ์ถ๊ฐ๋๋ฏ๋ก ์ด ์์ ์ค๊ณ ๋น๊ต์ฉ์ผ๋ก ์ฌ์ฉํด์ผ ํฉ๋๋ค.
Grouped broadcast
์
๋ ฅ X์์ Query๋ H๊ฐ head๋ก, Key์ Value๋ G๊ฐ head๋ก ํฌ์ํฉ๋๋ค.
Q = X ยท Wq -> [B, H, T, D]
K = X ยท Wk -> [B, G, T, D]
V = X ยท Wv -> [B, G, T, D]
๊ฐ Query head h๋ ๋ค์ ๊ทธ๋ฃน์ KV๋ฅผ ์ฌ์ฉํฉ๋๋ค.
g(h) = floor(h / (H / G))
score[h] = softmax(Q[h] ยท K[g(h)]แต / sqrt(D))
O[h] = score[h] ยท V[g(h)]
๋
ผ๋ฆฌ์ ์ผ๋ก๋ K/V๋ฅผ H/G๋ฒ ๋ฐ๋ณตํ ๊ฒ๊ณผ ๊ฐ์ง๋ง, ํจ์จ์ ์ธ attention kernel์ ๋์ผํ K/V๋ฅผ ์ค์ ๋ก ๋ณต์ ํ์ง ์๊ณ group index๋ก ์ฐธ์กฐํ ์ ์์ต๋๋ค. ๋ฐ๋ผ์ GQA๋ ํ๋์ attention ๊ฒฐ๊ณผ๋ฅผ ๋ชจ๋ head์ ๋ณต์ฌํ๋ ๋ฐฉ์์ด ์๋๋๋ค. Query๋ง๋ค ๋ค๋ฅธ score์ output์ ๊ณ์ฐํ๋, ์ฝ๋ K/V sequence๋ง ๊ทธ๋ฃน ๋ด๋ถ์์ ๊ณต์ ํฉ๋๋ค.
๊ทธ๋ฆผ 2. ๊ฐ Query group์ด ํ๋์ KV sequence๋ฅผ ๊ณต์ ํ๋ attention ๊ฒฝ๋ก
๋น๊ต/๋ถ์
MHA, GQA, MQA ๋น๊ต
| ํญ๋ชฉ | MHA | GQA | MQA |
|---|---|---|---|
| KV head ์ | H |
G, 1<G<H |
1 |
| KV cache ๋น์จ(MHA=1) | 1 | G/H |
1/H |
| K/V ํํ์ ๋ ๋ฆฝ์ฑ | ๊ฐ์ฅ ๋์ | ๊ทธ๋ฃน ๋ด๋ถ ๊ณต์ | ๋ชจ๋ Query๊ฐ ๊ณต์ |
| Decode KV read volume | ๊ฐ์ฅ ํผ | ์ค๊ฐ | ๊ฐ์ฅ ์์ |
| ๊ธฐ์กด MHA ์ ํ ๋์ด๋ | ํด๋น ์์ | ํ๊ท ํ๋ง + uptraining | ํ๊ท ํ๋ง + uptraining |
| ํ์งยท์๋ ์กฐ์ ํญ | ํ์ง ๊ธฐ์ค์ | G๋ก ์กฐ์ |
์๋ยท์ฉ๋ ์ต์ ํ, ํ์ง ์ํ ํผ |
GQA ๊ทธ๋ฃน ์ ์ ํ
G๋ฅผ ์๊ฒ ํ๋ฉด cache์ KV read volume์ ์ค์ง๋ง ํ KV ํํ์ ๊ณต์ ํ๋ Query head ์๊ฐ ๋์ด ํ์ง ์ ํ ์ํ์ด ์ปค์ง ์ ์์ต๋๋ค. ๋ฐ๋๋ก G๋ฅผ ํฌ๊ฒ ํ๋ฉด MHA์ ๊ฐ๊น์ด ํํ๋ ฅ์ ์ ์งํ์ง๋ง ๋ฉ๋ชจ๋ฆฌ ์ ๊ฐ ํญ๊ณผ decode ๋์ญํญ ์ด๋์ด ์ค์ด๋ญ๋๋ค. ๋ฐ๋ผ์ G๋ ๋จ์ํ ์ต๋ ์ ๊ฐ๊ฐ์ผ๋ก ๊ณ ๋ฅด๋ ๊ฒ์ด ์๋๋ผ ๋ชจ๋ธ์ ํ์ง ํ๊ฐ์ GPU/tensor parallel ๋ฐฐ์น ์ ์ฝ์ ํจ๊ป ๋ณด๊ณ ์ ํด์ผ ํฉ๋๋ค.
์๋ฅผ ๋ค์ด H=32, D=128, L=32, B=1, T=4096, BF16(s=2)์ด๋ฉด ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
| ๊ตฌ์กฐ | G |
์ ์ฒด KV cache ๊ทผ์ฌ๊ฐ |
|---|---|---|
| MHA | 32 | 2 GiB |
| GQA-8 | 8 | 512 MiB |
| GQA-4 | 4 | 256 MiB |
| MQA | 1 | 64 MiB |
์ด ๊ฐ์ ํ ์์ฒญ์ ๋ชจ๋ ๋ ์ด์ด์ 4096๊ฐ ํ ํฐ์ ํฉ์น ์ด๋ก ๊ฐ์ ๋๋ค. allocator metadata, batch, padding, ์์ํ scale์ ํฌํจํ์ง ์์์ต๋๋ค.
Prefill๊ณผ Decode์ ์ฐจ์ด
Prefill์์๋ ์ฌ๋ฌ ์
๋ ฅ ํ ํฐ์ ๋ณ๋ ฌ๋ก ์ฒ๋ฆฌํ๋ฏ๋ก GEMM ์ฒ๋ฆฌ๋๊ณผ ์ฐ์ฐ ํจ์จ์ด ์ค์ํฉ๋๋ค. Decode์์๋ ์ Query๊ฐ ๋ณดํต ํ ํ ํฐ์ฉ ๋ค์ด์ค๊ณ , ๊ฐ ๋ ์ด์ด๊ฐ ๊ณผ๊ฑฐ T๊ฐ ํ ํฐ์ K/V๋ฅผ ๋ค์ ์ฝ์ต๋๋ค. ์ด๋ GQA๋ ๊ณผ๊ฑฐ sequence์ KV head ์ ์์ฒด๋ฅผ G๊ฐ๋ก ์ค์ฌ HBM read pressure๋ฅผ ๋ฎ์ถฅ๋๋ค.
GQA๊ฐ attention์ ๋ชจ๋ ์ฐ์ฐ์ G/H ๋น์จ๋ก ์ค์ด๋ ๊ฒ์ ์๋๋๋ค. Query projection, Query head๋ณ score ๊ณ์ฐ, output projection์ ์ฌ์ ํ H๊ฐ Query head๋ฅผ ๊ธฐ์ค์ผ๋ก ์ํ๋ฉ๋๋ค. ์ค์ end-to-end ์ด๋์ context length, batch size, attention kernel, memory bandwidth, prefill/decode ๋น์จ์ ๋ฐ๋ผ ๋ฌ๋ผ์ง๋๋ค.
๋์ ์๋ฆฌ
1. MHA checkpoint์์ GQA๋ก ๋ณํ
๊ธฐ์กด MHA์ K/V projection์๋ H๊ฐ์ head๊ฐ ์์ต๋๋ค. ๋ชฉํ GQA๊ฐ G๊ฐ์ KV head๋ฅผ ์ฌ์ฉํ๊ณ H/G๊ฐ ์ ์๋ผ๋ฉด, ์๋ K/V head๋ฅผ ๊ทธ๋ฃน๋ณ๋ก ๋ฌถ๊ณ ๊ฐ ๊ทธ๋ฃน์ ๊ฐ์ค์น๋ฅผ ํ๊ท ํ๋งํ์ฌ ์ K/V projection์ ์ด๊ธฐํํ ์ ์์ต๋๋ค. Query projection๊ณผ output projection์ ์ ์งํฉ๋๋ค.
๊ทธ๋ฆผ 3. ๊ทธ๋ฃน๋ณ K/V ํ๊ท ํ๋ง๊ณผ uptraining์ ํตํ checkpoint ๋ณํ
for g in range(G):
start = g * (H // G)
end = (g + 1) * (H // G)
Wk_g = mean(Wk_heads[start:end], axis=head)
Wv_g = mean(Wv_heads[start:end], axis=head)
ํ๊ท ํ๋ง์ ๋ณํ ์งํ์ ์ด๊ธฐํ ๋ฐฉ๋ฒ์ด๋ฉฐ, ํ์ง ํ๋ณต์ ๋ณด์ฅํ๋ ๊ฒ ์์ฒด๋ ์๋๋๋ค. GQA ๋ ผ๋ฌธ์ ๋ณํํ checkpoint๋ฅผ ์ ํ๋ ์ถ๊ฐ ํ์ต์ผ๋ก ๋ณด์ ํ๋ uptraining์ ์ฌ์ฉํ์ต๋๋ค. ์ค์ ์ ํ์์๋ tokenizer, RoPE ์ค์ , optimizer ์ํ, calibration ๋ฐ์ดํฐ์ ํ๊ฐ workload๋ฅผ ๋ชจ๋ธ๋ณ๋ก ๋ง์ถฐ์ผ ํฉ๋๋ค.
2. Projection๊ณผ RoPE
๊ฐ decoder layer๋ hidden state์์ Q, K, V๋ฅผ ์์ฑํฉ๋๋ค. RoPE๋ฅผ ์ฌ์ฉํ๋ ๋ชจ๋ธ์ด๋ผ๋ฉด Query์ Key์ ์์น ํ์ ์ ์ ์ฉํ ๋ค Key๋ฅผ KV cache์ ์ถ๊ฐํฉ๋๋ค. GQA๋ Key/Value head ์๋ฅผ ์ค์ด๋ ๊ตฌ์กฐ์ด๋ฏ๋ก Query head๋ณ ์์น ์ฒ๋ฆฌ์ score ๊ณ์ฐ์ ๋
๋ฆฝ์ ์ผ๋ก ๋จ์ต๋๋ค.
Q_t = RoPE(project_Q(x_t)) # [B, H, 1, D]
K_t = RoPE(project_K(x_t)) # [B, G, 1, D]
V_t = project_V(x_t) # [B, G, 1, D]
append(K_cache, K_t)
append(V_cache, V_t)
3. Incremental decode
์ ํ ํฐ t๋ฅผ ์ฒ๋ฆฌํ ๋ ํ์ฌ Query Q_t[h]๋ ์์ ์ด ์ํ ๊ทธ๋ฃน g(h)์ ์ ์ฒด cache์ ๋ด์ ํฉ๋๋ค. ๊ทธ๋ฃน์ด ๊ฐ์๋ Query๊ฐ ๋ค๋ฅด๋ฏ๋ก attention probability์ output์ ์๋ก ๋ค๋ฆ
๋๋ค.
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 range(H):
g = h // (H // G)
a_h = softmax(q_t[h] @ K_cache[g].T / sqrt(D))
o_h = a_h @ V_cache[g]
y_t = concat(o_0, ..., o_{H-1}) @ Wo
์ด ๊ฒฝ๋ก์์ cache์ ์๊ฐ์ถ ๊ธธ์ด T๋ ๋์ผํ์ง๋ง KV head ์ถ์ด H์์ G๋ก ์ค์ด๋ญ๋๋ค. ์ปค๋์ด K/V๋ฅผ materializeํ์ง ์๊ณ group mapping์ ์ฒ๋ฆฌํ๋ฉด ์ค๊ฐ broadcast buffer๋ ์ค์ผ ์ ์์ต๋๋ค.
4. Tensor parallelism๊ณผ kernel ์ ์ฝ
Tensor parallelism์์๋ Query head์ KV head๊ฐ GPU shard์ ์ด๋ป๊ฒ ๋ฐฐ์น๋๋์ง๊ฐ ์ค์ํฉ๋๋ค. G๊ฐ GPU ์ ๋๋ tensor-parallel degree์ ์ ๋ง์ง ์์ผ๋ฉด KV head๋ฅผ ๊ท ๋ฑํ๊ฒ ๋๋๊ธฐ ์ด๋ ต๊ณ , attention ์ ์ KV๋ฅผ ๋ณต์ ํ๊ฑฐ๋ ํต์ ํ๋ ๊ฒฝ๋ก๊ฐ ์๊ธธ ์ ์์ต๋๋ค. ๋ฐ๋ผ์ ์ด๋ก ์ ์ธ G/H cache ๊ฐ์๊ฐ ๊ฐ์ ๋น์จ์ latency ๊ฐ์๋ก ์ด์ด์ง๋ค๊ณ ๊ฐ์ ํ๋ฉด ์ ๋ฉ๋๋ค.
๊ตฌํ ์ ๋ค์์ ํ์ธํด์ผ ํฉ๋๋ค.
num_attention_heads,num_key_value_heads,head_dim์ ์ ํฉ์ฑ๊ณผH % G == 0์กฐ๊ฑด- KV cache layout์ด backend๊ฐ ์๊ตฌํ๋
[batch, kv_heads, sequence, head_dim]๊ณ์ด์ธ์ง ์ฌ๋ถ repeat_kv๊ฐ ์ค์ ๋ฉ๋ชจ๋ฆฌ ๋ณต์ ์ธ์ง fused kernel ๋ด๋ถ์ ๋ ผ๋ฆฌ์ broadcast์ธ์ง ์ฌ๋ถ- tensor parallel shard๋ณ KV head ๋ฐฐ์น์ all-gather/broadcast ํต์ ๋
- GQA์ FlashAttention, PagedAttention, KV cache quantization์ shapeยทscale ํธํ์ฑ
์ฅ๋จ์
์ฅ์
- MHA ๋๋น KV cache ์ฉ๋๊ณผ decode ๋จ๊ณ์ KV memory read๋ฅผ
G/H์์ค์ผ๋ก ์ค์ผ ์ ์์ต๋๋ค. - Query head ์๋ฅผ ์ ์งํ๋ฏ๋ก MQA๋ณด๋ค ํํ ๊ณต๊ฐ๊ณผ ํ์ง์ ๋ ๋ณด์กดํ ์ฌ์ง๊ฐ ์์ต๋๋ค.
- ๊ธด context, ํฐ batch, beam search์ฒ๋ผ KV cache๊ฐ ์ปค์ง๋ serving workload์ ์ ๋ฆฌํฉ๋๋ค.
G๋ฅผ ์กฐ์ ํด ํ์งยท๋ฉ๋ชจ๋ฆฌยท๋์ญํญ ์ฌ์ด์ ์ ์ถฉ์ ์ ๋ชจ๋ธ๋ณ๋ก ์ ํํ ์ ์์ต๋๋ค.- PagedAttention์ cache ๋ฐฐ์น ๋ฐฉ์์, KV quantization์ ์์ ์ ๋ฐ๋๋ฅผ ๋ฐ๊พธ๋ฏ๋ก GQA์ ์ง๊ต์ ์ผ๋ก ๊ฒฐํฉํ ์ ์์ต๋๋ค.
๋จ์
- K/V ํํ์ ๊ณต์ ํ๋ฏ๋ก MHA์ head๋ณ ๋ ๋ฆฝ์ฑ๋ณด๋ค ํํ๋ ฅ์ด ์ค๊ณ ํ์ง ์ ํ๊ฐ ๋ฐ์ํ ์ ์์ต๋๋ค.
- ๊ธฐ์กด MHA checkpoint๋ฅผ ๋จ์ํ head๋ฅผ ์ญ์ ํ๋ ๋ฐฉ์์ผ๋ก ๋ณํํ๋ฉด ๋ถํฌ๊ฐ ๋ฐ๋๋ฏ๋ก ํ๊ท ํ๋ง๊ณผ ์ถ๊ฐ ํ์ต์ด ํ์ํ ์ ์์ต๋๋ค.
- ์์
G๋ tensor parallel shard์ KV head๋ฅผ ๋ฐฐ์นํ๊ธฐ ์ด๋ ต๊ฒ ๋ง๋ค์ด broadcast ๋๋ ํต์ ๋น์ฉ์ ์ ๋ฐํ ์ ์์ต๋๋ค. - Prefill์ด compute-bound์ด๋ฉด decode์์์ KV read ์ ๊ฐ์ด ์ ์ฒด ์์ฒญ latency์ ์ ํ์ ์ผ๋ก๋ง ๋ฐ์๋ฉ๋๋ค.
- ๋ชจ๋ธ ์ค์ ์ ๋ฐ๊พธ๋ ์ํคํ ์ฒ ๊ธฐ๋ฒ์ด๋ฏ๋ก ๊ธฐ์กด weight์ inference backend๊ฐ GQA shape์ ์ง์ํด์ผ ํฉ๋๋ค.
๊ด๋ จ ๊ธฐ์ ๋ฐ ์ฐธ๊ณ ๋ฌธํ
| ๋ฌธ์/์ฐ๊ตฌ | ์ฐ๊ฒฐ์ |
|---|---|
| LLM Basics | Transformer decoder, prefill/decode, KV cache ๊ธฐ๋ณธ ๊ฐ๋ |
| MQA Analysis | GQA์ ์ ๋์ ์ธ MHA์ MQA์ ๊ตฌ์กฐยทcache ๋น๊ต |
| PagedAttention Analysis | KV cache๋ฅผ ๋ธ๋ก์ผ๋ก ๋ฐฐ์นํ๊ณ ๊ด๋ฆฌํ๋ serving ๊ธฐ๋ฒ |
| KV Cache Quantization Analysis | GQA์ ๊ฒฐํฉํ ์ ์๋ KV ์์ ์ ๋ฐ๋ ์ถ์ |
| MLA Analysis | KV head ๊ณต์ ๊ฐ ์๋ latent ์์ถ์ ์ฌ์ฉํ๋ ๋์ |
| Ainslie et al., GQA: Training Generalized Multi-Query Transformer Models from Multi-Head Checkpoints | GQA ์ ์, MHA checkpoint ๋ณํ, 5% uptraining recipe |
| Shazeer, Fast Transformer Decoding: One Write-Head is All You Need | MQA์ incremental decoding์ memory-bandwidth ๋ฌธ์ |
| Hugging Face LlamaConfig ๋ฌธ์ | num_key_value_heads๋ก MHA/GQA/MQA๋ฅผ ์ค์ ํ๋ ๊ท์น |
ํต์ฌ ์ ๋ฆฌ
GQA๋ H๊ฐ์ Query head๋ฅผ ์ ์งํ๋ฉด์ G๊ฐ์ KV head๋ง ๋๊ณ , ๊ฐ KV head๋ฅผ H/G๊ฐ์ Query head๊ฐ ๊ณต์ ํ๋ Attention ๊ตฌ์กฐ์
๋๋ค. KV cache ์ฉ๋์ KV head ์์ ๋น๋กํ๋ฏ๋ก MHA ๋๋น G/H ์์ค์ผ๋ก ์ค์ง๋ง, Query ๊ณ์ฐ๊ณผ ๋ชจ๋ head์ score ๊ณ์ฐ์ด ๊ฐ์ ๋น์จ๋ก ์ค์ด๋๋ ๊ฒ์ ์๋๋๋ค. ๊ธฐ์กด MHA checkpoint๋ ๊ทธ๋ฃน๋ณ K/V ํ๊ท ํ๋ง ํ ์ ํ๋ uptraining์ผ๋ก GQA์ ๋ง์ถ ์ ์์ผ๋ฉฐ, G ์ ํ์ ํ์ง๋ฟ ์๋๋ผ tensor parallel ๋ฐฐ์น์ kernel ์ง์๊น์ง ๊ณ ๋ คํด์ผ ํฉ๋๋ค. PagedAttention๊ณผ KV cache quantization์ ์๋ก ๋ค๋ฅธ ์ถ์ ์ต์ ํํ๋ฏ๋ก GQA์ ํจ๊ป ์ ์ฉํ ์ ์์ต๋๋ค.