---
title: "LLM 양자화하면 메모리는 얼마나 줄고 무엇을 잃을까? GPTQ·AWQ·GGUF·FP8 고르는 기준"
id: "2138"
type: "post"
slug: "llm-quantization-gptq-awq-gguf-pruning-distillation-guide2"
published_at: "2026-11-21T15:09:08+00:00"
modified_at: "2026-11-21T15:09:08+00:00"
url: "https://doyouknow.kr/llm-quantization-gptq-awq-gguf-pruning-distillation-guide2/"
markdown_url: "https://doyouknow.kr/llm-quantization-gptq-awq-gguf-pruning-distillation-guide2.md"
excerpt: "BF16 모델을 4비트로 양자화하면 가중치는 이론상 4분의 1이 되지만, llama.cpp Q4_K_M 파일은 스케일 값과 4비트로 줄이지 않는 텐서 때문에 Llama 3.1 기준 그보다 22-23% 큽니다. 품질은 FP8이면 거의 그대로였고, 4비트는 가장 작은 모델에서 가장 많이 떨어졌습니다. 형식은 실행 엔진과 GPU..."
taxonomy_category:
  - "AI"
taxonomy_post_tag:
  - "AWQ"
  - "FP8"
  - "GGUF"
  - "GPTQ"
  - "INT4"
  - "INT8"
  - "llama.cpp"
  - "LLM 양자화"
  - "LLM 추론"
  - "NVFP4"
  - "Ollama"
  - "Quantization"
  - "vLLM"
  - "로컬 LLM"
---

![Llm Quantization Guide2 Featured](https://doyouknow.kr/wp-content/uploads/2026/11/xllm-quantization-guide2-featured.webp.pagespeed.ic.B3-dODc7Iw.webp)

BF16 모델을 4비트로 양자화(quantization)하면 가중치 메모리는 이론상 4분의 1이 되지만, llama.cpp의 Q4_K_M 파일은 Llama 3.1 기준 **그 계산값보다 22-23% 큽니다**. 여기에 문맥 길이에 비례하는 KV cache(KV 캐시)가 따로 붙습니다. 품질은 FP8이면 거의 그대로였고, 4비트는 가장 작은 모델에서 가장 많이 떨어졌습니다. 무엇을 고를지는 실행 엔진과 GPU가 먼저 좁혀 줍니다. 혼자 llama.cpp·Ollama로 돌리면 GGUF Q4_K_M, vLLM 서버라면 Ada·Hopper 이상에서 FP8, 메모리가 모자라면 GPTQ·AWQ 4비트, Blackwell이면 NVFP4가 출발점입니다.

Llama 3.1 70B Q4_K_M은 35GB가 아니라 43.1GB입니다. 품질 수치는 Llama 3.1 전 크기를 50만 번 넘게 평가한 연구에서 나왔습니다. BF16 평균 점수를 100으로 놓으면 FP8은 거의 100이었고, 가중치만 양자화(weight-only)한 4비트는 70B·405B에서 97-99, 가장 작은 8B는 어려운 과제 묶음에서 96.1이었습니다. 같은 연구가 추론 과제로 따로 잰 증류 모델 가운데서는 1.5B가 93.5로 가장 낮았습니다.

GPTQ와 AWQ는 4비트 가중치를 만드는 알고리즘이고, GGUF는 llama.cpp가 읽는 파일 형식이며, FP8·NVFP4는 GPU가 계산하는 숫자 형식입니다.

## 4비트로 줄여도 파일은 4분의 1보다 큽니다

가중치가 차지하는 바이트는 **파라미터 수 × 파라미터 하나당 비트 수 ÷ 8**입니다. Llama 3.1 70B는 BF16이면 약 140GB, 8비트면 70GB, 4비트면 35GB가 나와야 합니다. llama.cpp 저장소가 공개한 실제 Q4_K_M 파일 크기와 나란히 놓으면 이렇습니다.

| 모델 | BF16(계산) | 8비트(계산) | 4비트(계산) | Q4_K_M 실제 파일 | 4비트 계산값 대비 |
| --- | --- | --- | --- | --- | --- |
| Llama 3.1 8B | 16.1GB | 8.0GB | 4.0GB | 4.9GB | +22% |
| Llama 3.1 70B | 140.5GB | 70.2GB | 35.1GB | 43.1GB | +23% |
| Llama 3.1 405B | 812.6GB | 406.3GB | 203.1GB | 249.1GB | +23% |

*계산값의 파라미터 수는 llama.cpp `tools/quantize` README에 적힌 F32 원본 크기를 4바이트로 나눠 구했습니다. 실제 파일 크기도 같은 README 값입니다(2026-11-21 확인).*

![Llama 3.1 70B 가중치 크기 가로 막대 그래프. BF16 계산값 140.5GB, 8비트 계산값 70.2GB, 4비트 계산값 35.1GB, llama.cpp Q4_K_M 실제 파일 43.1GB로 4비트 계산값보다 23% 크다](https://doyouknow.kr/wp-content/uploads/2026/11/xllm-quantization-guide2-weight-size.webp.pagespeed.ic.ntrfzkpfLV.webp)

4비트 계산값은 35.1GB지만 실제 Q4_K_M 파일은 43.1GB입니다

세 크기 모두 비슷하게 4.9 bpw(bits per weight, 가중치 하나당 평균 비트 수)가 나옵니다. 남는 0.9비트는 두 군데에서 생깁니다.

첫째는 스케일(scale) 값입니다. 4비트 정수는 16칸뿐이라 칸 번호만으로는 원래 값의 크기를 알 수 없습니다. 그래서 값 수십 개를 한 묶음으로 보고, 그 묶음에서 한 칸이 실제로 얼마인지를 따로 적어 둡니다. 묶음이 작을수록 원래 값에 가깝게 맞추지만 적어 둘 스케일이 늘어납니다.

| 방식 | 값 | 묶음 크기와 스케일 | 값 하나당 평균 비트 |
| --- | --- | --- | --- |
| INT4, 그룹 128(GPTQ·AWQ에서 흔한 설정) | 4비트 정수 | 128개마다 FP16 스케일 1개 | 약 4.13 |
| 같은 설정에 4비트 zero-point(실수 0이 놓이는 칸 번호) 추가 | 4비트 정수 | 128개마다 FP16 스케일 + 4비트 zero-point | 약 4.16 |
| MXFP4 | 4비트 부동소수점(E2M1) | 32개마다 8비트 2의 거듭제곱 스케일 | 4.25 |
| NVFP4 | 4비트 부동소수점(E2M1) | 16개마다 FP8(E4M3) 스케일 + 텐서마다 FP32 스케일 | 약 4.5 |

*NVFP4의 4.5비트는 NVIDIA 기술 블로그의 값이고, 나머지는 묶음 구조로 계산한 값입니다.*

둘째는 4비트로 줄이지 않는 텐서입니다. Q4_K_M은 모든 텐서를 같은 4비트로 만들지 않고 일부를 더 높은 비트로 섞습니다. `llama-quantize`의 `--pure` 옵션이 이 혼합을 끄는 옵션이고, 출력층과 토큰 임베딩의 형식을 따로 정하는 옵션도 있습니다. 이 두 텐서는 생각보다 큽니다. Llama 3.1 8B는 어휘 128,256개 × 은닉 차원 4,096인 행렬이 입력 임베딩과 출력층 `lm_head`에 하나씩 있어 합치면 약 10.5억 개, 전체 파라미터의 13%입니다. 이미지·음성 인코더가 달린 모델은 llama.cpp 문서도 그 인코더를 보통 BF16이나 8비트로 둔다고 안내합니다.

이름에 적힌 크기와 비트만으로 어림하면 틀리기 쉽습니다. 이 블로그의 [DGX Spark 운영 기록](https://doyouknow.kr/dgx-spark-gb10-worth-it/)
에서 쓰는 `nvidia/Qwen3.8-Flash-Next-FP4-Local`은 흔히 125B 모델로 불리지만, 모델 카드에는 125B 말고도 n-gram 임베딩 51B와 MTP(다음 토큰 여러 개를 미리 예측하는 모듈) 4B가 따로 적혀 있습니다. 전문가(expert) 가중치는 NVFP4지만 attention(어텐션) 층은 MXFP8이고, 체크포인트는 디스크에서 약 96GiB입니다. NVIDIA의 DGX Spark 실행 예시는 이 n-gram 임베딩 표를 GPU 메모리가 아니라 디스크에 두는 설정(`VLLM_PLE_TABLE_MEMORY="disk"`)을 씁니다.

## 가중치 다음에는 KV cache가 붙습니다

GPU에는 모델 파일 말고도 KV cache가 올라갑니다. 모델은 앞서 읽은 토큰마다 key와 value를 저장해 두고 다음 토큰을 만들 때 다시 읽습니다. 이 KV cache는 **2(K·V) × 층 수 × KV 헤드 수 × 헤드 차원 × 바이트 수 × 토큰 수**만큼 들고, 동시에 처리하는 요청 수만큼 또 곱해집니다. Llama 3.1 두 모델의 config 값을 넣은 결과입니다.

| 모델(층·KV 헤드·헤드 차원) | 토큰 하나(16비트) | 8K, 16비트 | 32K, 16비트 | 32K, q8_0 |
| --- | --- | --- | --- | --- |
| Llama 3.1 8B(32·8·128) | 128KiB | 1.0GiB | 4.0GiB | 2.1GiB |
| Llama 3.1 70B(80·8·128) | 320KiB | 2.5GiB | 10.0GiB | 5.3GiB |

*요청 1개 기준입니다. 16비트는 llama.cpp 기본값 f16(BF16도 크기는 같음), q8_0은 llama.cpp의 8비트 KV cache 형식(값 32개마다 FP16 스케일, 값당 8.5비트)입니다. 모든 층이 문맥 전체를 저장하는 모델의 값이고, 최근 토큰만 저장하는 층이나 선형 attention 층을 섞은 모델은 덜 늘어납니다.*

이제 70B Q4_K_M(43.1GB, 즉 40.1GiB)을 llama.cpp로 24GB GPU 두 장에 나눠 올린다고 해 보겠습니다. RTX 4090 같은 24GB 카드는 `nvidia-smi`에 장당 24,564MiB(약 24.0GiB)로 잡혀서 두 장이면 약 48.0GiB입니다. llama.cpp는 기본값(`--split-mode layer`)에서 층을 두 GPU에 나눠 싣고, KV cache도 그 층을 따라 나뉩니다.

| 문맥·KV cache 형식 | 가중치 + KV cache | 두 장 합계(48.0GiB) 대비 |
| --- | --- | --- |
| 8K, f16 | 42.6GiB | 5.3GiB 남음 |
| 32K, q8_0 | 45.5GiB | 2.5GiB 남음 |
| 32K, f16 | 50.1GiB | 2.2GiB 넘침 |

![70B Q4_K_M 가중치 40.1GiB에 KV cache를 더한 누적 막대와 24GB GPU 두 장 합계 48.0GiB 기준선. 8K f16 KV는 5.3GiB 남고, 32K q8_0 KV는 2.5GiB 남으며, 32K f16 KV는 2.2GiB 넘친다(가중치와 KV cache만 더한 계산값)](https://doyouknow.kr/wp-content/uploads/2026/11/xllm-quantization-guide2-kv-budget.webp.pagespeed.ic.QDW3FHL-s9.webp)

같은 32K라도 KV cache를 q8_0으로 줄이면 가중치와 합쳐 2.5GiB가 남습니다

남는 값에는 아직 **엔진이 계산 중에 쓰는 버퍼와 CUDA 런타임 몫, 두 GPU에 나뉘는 실제 비율**이 빠져 있습니다. 32K 문맥이 필요하면 `--flash-attn on --cache-type-k q8_0 --cache-type-v q8_0`으로 KV cache를 8비트로 줄이는 것이 첫 선택지입니다. llama.cpp는 V cache를 양자화하려면 Flash Attention이 켜져 있어야 하고, 꺼 두면 시작할 때 오류를 냅니다. 모델·양자화·문맥·동시 요청 수·GPU를 바꿔 가며 가중치와 KV cache를 나눠 보려면 [LLM VRAM 계산기](https://doyouknow.kr/llm-vram-calculator/)
에 넣어 보면 됩니다.

## 주요 공개 모델은 GPU 메모리를 얼마나 차지할까

로컬에서 많이 내려받는 공개 가중치 모델 일곱 개를 골라, Hugging Face에 올라온 실제 GGUF 파일 크기에 8K 문맥의 KV cache를 더해 봤습니다. 그중 셋은 층마다 여러 전문가 중 일부만 골라 쓰는 MoE(Mixture of Experts) 모델입니다. 단위는 모두 GiB입니다.

| 모델 | 전체(활성) 파라미터 | BF16 | Q8_0 | Q4_K_M | KV 8K | Q4_K_M + KV 8K |
| --- | --- | --- | --- | --- | --- | --- |
| Llama 3.1 8B Instruct | 8.0B | 14.96 | 7.95 | 4.58 | 1.00 | 5.58 |
| Gemma 4 12B it | 12.0B | 22.28 | 11.80 | 6.63 | 구조가 달라 별도 | – |
| Qwen3.8 27B | 27.8B | 51.75 | 26.63 | 18.07 | 0.50 | 18.57 |
| Llama 3.3 70B Instruct | 70.6B | 131.42 | 69.83 | 39.60 | 2.50 | 42.10 |
| gpt-oss-20b(MoE) | 21B(3.6B) | 39.12 | 11.28 | 10.83 | 0.19 | 11.02 |
| Qwen3.6 35B-A3B(MoE) | 36.0B(3B) | 66.97 | 34.37 | 19.13 | 0.16 | 19.29 |
| gpt-oss-120b(MoE) | 117B(5.1B) | 217.93 | 59.03 | 58.46 | 0.28 | 58.74 |

*Q8_0·Q4_K_M은 2026-11-21 기준 Hugging Face GGUF 저장소 파일의 실제 바이트 수를 GiB로 바꾼 값이고, 분할 파일은 합쳤습니다. 모델마다 저장소는 하나만 썼습니다(Llama 3.1 8B는 bartowski, Qwen 두 모델은 ggml-org, 나머지는 unsloth). BF16은 원본 파라미터 수 × 2바이트로 계산했고, gpt-oss 두 모델은 원본이 MoE 가중치를 MXFP4로 배포해서 BF16 값은 비교용 계산입니다. KV 8K는 llama.cpp 기본값 f16, 요청 1개 기준입니다. 이미지 입력용 보조 파일(mmproj)과 선형 attention의 고정 상태는 넣지 않은, 텍스트 추론용 가중치와 KV cache의 합입니다.*

KV 열은 모델 구조를 따라 계산했습니다. Qwen 두 모델은 4층 중 1층만 문맥 전체의 KV를 저장하고 나머지 층은 문맥 길이와 상관없이 크기가 고정된 상태를 쓰는 선형 attention이라, 전체 문맥 층만 셌습니다. gpt-oss는 층 절반이 최근 128토큰만 저장해서 그 층의 몫은 몇 MiB에 그칩니다. Gemma 4는 1,024토큰만 저장하는 층과 문맥 전체를 저장하는 층을 섞고, 두 층의 KV 헤드 수와 헤드 차원이 서로 달라 앞 절의 식 하나로 계산하지 않았습니다.

![공개 모델별 Q4_K_M 가중치와 KV cache 8K를 더한 메모리 가로 막대와 GPU 용량 기준선(12·16·24·48·80GB). Llama 3.1 8B 5.6GiB, gpt-oss-20b(MoE) 11.0GiB, Qwen3.8 27B 18.6GiB, Qwen3.6 35B-A3B(MoE) 19.3GiB, Llama 3.3 70B 42.1GiB, gpt-oss-120b(MoE) 58.7GiB. Gemma 4 12B는 가중치 6.6GiB이고 KV는 별도](https://doyouknow.kr/wp-content/uploads/2026/11/xllm-quantization-guide2-models-vram.webp.pagespeed.ic.vB-v4oW-xO.webp)

가중치와 8K KV cache만 더하면 24GB에는 Qwen 두 모델까지, Llama 3.3 70B는 48GB, gpt-oss-120b는 80GB 급이 필요합니다

MoE 모델은 토큰마다 일부 전문가만 계산에 쓰지만, 가중치를 모두 GPU에 올린다면 **메모리에는 전문가 전체가 올라갑니다**. Qwen3.6 35B-A3B는 토큰당 약 3B만 쓰는데도 Q4_K_M 파일이 19.1GiB입니다. gpt-oss 두 모델은 Q8_0과 Q4_K_M의 크기가 거의 같습니다. MoE 가중치가 이미 MXFP4로 배포됐기 때문에 Q4_K_M으로 바꿔도 줄어드는 몫이 거의 없습니다. KV cache도 구조에 따라 크게 갈려서, 모든 층이 문맥 전체를 저장하는 Llama 3.3 70B는 8K에 2.5GiB인데 Qwen3.6 35B-A3B는 0.16GiB입니다.

마지막 열을 GPU 메모리에 대 보면, 12GB 카드에는 Llama 3.1 8B(5.6GiB)가 넉넉히 들어가고 gpt-oss-20b(11.0GiB)는 거의 꽉 찹니다. Gemma 4 12B는 가중치가 6.6GiB로 둘 사이에 들고, KV cache는 층 구성이 달라 따로 재야 합니다. 16GB면 gpt-oss-20b까지, 24GB면 Qwen3.8 27B(18.6GiB)와 Qwen3.6 35B-A3B(19.3GiB)까지 올라갑니다. Llama 3.3 70B(42.1GiB)는 48GB 카드, 또는 앞 절처럼 층을 나눠 싣는 24GB 두 장이 필요합니다. gpt-oss-120b(58.7GiB)는 48GB를 넘으므로 80GB 카드 한 장이나 [DGX Spark](https://doyouknow.kr/dgx-spark-gb10-worth-it/)
 같은 128GB 통합 메모리 장비에서 여유 있게 돌아갑니다. 24GB 카드가 `nvidia-smi`에서 약 24.0GiB로 잡히듯 GPU의 표시 용량은 GiB 값에 가까워서 표와 바로 견줄 수 있습니다. 합계가 카드 용량에 바짝 붙는 조합은 앞 절에서 본 엔진 버퍼 몫까지 생각해야 하니, [LLM VRAM 계산기](https://doyouknow.kr/llm-vram-calculator/)
에서 문맥 길이와 동시 요청 수를 바꿔 가며 다시 계산해 보면 됩니다.

## 양자화는 실수를 16칸짜리 눈금에 맞추는 일입니다

4비트 양자화를 코드로 쓰면 몇 줄입니다. 값의 최솟값과 최댓값 사이를 16칸으로 나눠 한 칸의 크기(스케일)를 구하고, 실수 0이 몇 번째 칸에 오는지 나타내는 zero-point를 정한 뒤, 각 값을 가장 가까운 칸 번호로 바꿉니다. 계산할 때는 칸 번호에서 zero-point를 빼고 스케일을 곱해 되돌립니다.

Python 3에서 실행하면 스케일 0.0307, zero-point 5, 칸 번호 `[9, 4, 8, 0, 6, 15, 3, 7]`이 나오고, 되돌린 값과 원래 값의 차이는 최대 0.012입니다. 0.02가 0.031로 돌아오는 식입니다. 이 차이가 층마다 쌓이는 것이 양자화 오차입니다.

zero-point를 두지 않고 0을 가운데 칸에 고정하면 대칭(symmetric) 양자화입니다. 계산이 단순해서 8비트에서 많이 쓰고, 값이 한쪽으로 치우친 묶음에서는 칸 일부를 버리게 됩니다. 실제 모델에서 더 중요한 선택은 스케일 하나가 몇 개의 값을 맡느냐입니다.

| 스케일 하나가 맡는 범위 | 장점 | 약점 | 쓰이는 예 |
| --- | --- | --- | --- |
| 텐서 전체(per-tensor) | 저장할 스케일이 거의 없음 | 튀는 값 하나가 눈금 전체를 넓힘 | FP8 활성값(activation), NVFP4의 2단계 스케일 |
| 출력 채널 한 줄(per-channel) | 행마다 크기 차이를 흡수 | 4비트에서는 눈금이 여전히 거침 | FP8·INT8 가중치 |
| 값 16-128개 묶음(group-wise) | 4비트에서도 오차가 작음 | 스케일 저장량이 늘어남 | GPTQ·AWQ 그룹 128, MXFP4 32, NVFP4 16 |

![어두운 남색 배경에서 빛나는 청록 구슬들이 떨어져 일정한 간격의 컵에 하나씩 들어가고, 하나는 컵 가장자리에 걸려 있다. 상단에 "연속된 값을 정해진 칸에 맞추는 일"이라는 문구가 있다](https://doyouknow.kr/wp-content/uploads/2026/11/xllm-quantization-guide2-grid.webp.pagespeed.ic.lck5Xj8xyu.webp)

양자화는 연속된 값을 정해진 칸에 맞추는 일입니다

무엇을 양자화하느냐도 갈립니다. W4A16은 가중치만 4비트로 저장하고 계산 직전에 16비트로 되돌립니다. 메모리와 메모리 대역폭은 아끼지만 행렬 곱셈 자체는 16비트로 합니다. W8A8은 활성값까지 8비트로 바꿔 GPU의 8비트 Tensor Core로 곱합니다. 연산까지 줄어드는 대신, 활성값에는 유난히 큰 값이 섞여 나와서 정수 8비트로 맞추기가 가중치보다 어렵습니다. Llama 3.1 전 크기를 평가한 Kurtic 등의 연구진은 70B를 INT8로 양자화할 때 SmoothQuant로 활성값의 큰 값을 가중치 쪽으로 옮겼습니다.

만드는 시점도 다릅니다. 대부분은 학습이 끝난 모델에 보정 데이터(calibration data)를 조금 흘려 통계를 잡고 변환하는 PTQ(Post-Training Quantization, 학습 후 양자화)입니다. GPTQ, AWQ, llama.cpp의 imatrix가 여기에 속합니다.

반대로 양자화된 상태로 학습을 더 시키는 QAT(Quantization-Aware Training, 양자화 인식 학습) 계열은 대개 모델을 만든 회사가 직접 해서 체크포인트로 내놓습니다. OpenAI의 gpt-oss-120b는 MoE 가중치를 MXFP4로 둔 채 후속 학습을 했고 평가도 그 상태로 했습니다. NVIDIA의 Qwen3.8 FP4-Local은 원래 정밀도 모델의 출력을 따라가도록 4비트 모델을 추가 학습하는 QAD(Quantization-Aware Distillation, 양자화 인식 증류)로 만들었습니다.

## GPTQ·AWQ·GGUF·FP8은 서로 다른 층의 이름입니다

양자화 모델 하나에는 세 가지 결정이 들어 있습니다. 숫자를 어떤 형식으로 저장할지, 그 숫자를 어떤 알고리즘으로 정할지, 어떤 파일에 담아 어떤 엔진이 읽을지입니다.

![양자화된 모델 하나에 들어 있는 세 가지 결정. 숫자 형식(어떤 값으로): INT4·INT8·FP8·MXFP4·NVFP4. 알고리즘(어떻게 맞추나): GPTQ·AWQ·반올림(RTN)·imatrix. 파일 형식(무엇이 읽나): safetensors는 vLLM·TensorRT-LLM·Transformers, GGUF는 llama.cpp·Ollama](https://doyouknow.kr/wp-content/uploads/2026/11/xllm-quantization-guide2-layers.webp.pagespeed.ic.miVus1hvMj.webp)

형식·알고리즘·파일은 서로 다른 층의 결정입니다

| 이름 | 무엇인가 | 핵심 동작 | 주로 만나는 곳 |
| --- | --- | --- | --- |
| GPTQ | 가중치 양자화 알고리즘(2022) | 층마다 출력 오차를 2차 정보로 보정하며 가중치를 차례로 양자화 | vLLM·Transformers용 4비트(W4A16) 체크포인트 |
| AWQ | 가중치 양자화 알고리즘(2023) | 활성값이 큰 채널의 가중치를 키우고 입력은 그만큼 줄여 보호, 역전파 없음 | 같은 곳 |
| GGUF | ggml 계열 파일 형식 | 가중치와 토크나이저·설정을 한 파일에 담음, Q4_K_M 같은 타입 | llama.cpp, Ollama |
| FP8 | 8비트 부동소수점 형식 | E4M3(지수 4·가수 3), E5M2(지수 5·가수 2) | Ada·Hopper 이상 GPU의 W8A8 |
| MXFP4 | 4비트 부동소수점 + 32개 묶음 스케일 | 스케일이 2의 거듭제곱 | gpt-oss의 MoE 가중치 |
| NVFP4 | 4비트 부동소수점 + 16개 묶음 FP8 스케일 | 2단계 스케일(묶음·텐서) | Blackwell GPU |

GPTQ는 한 층의 가중치를 열 단위로 양자화하면서, 방금 생긴 오차를 아직 양자화하지 않은 열들이 메우도록 조금씩 고칩니다. 어느 방향으로 고쳐야 층의 출력이 덜 흔들리는지는 보정 데이터로 구한 2차 정보(헤시안 근사)로 판단합니다. 원 논문은 175B 모델을 A100(80GB) 한 장에서 약 4시간 만에 3-4비트로 만들었고, 정확도 손실은 작았다고 보고합니다.

AWQ는 가중치 중 약 1%만 잘 지켜도 오차가 크게 준다는 관찰에서 출발합니다. 어느 채널이 중요한지는 가중치 값이 아니라 그 채널로 들어오는 활성값의 크기로 고릅니다. 중요한 채널만 더 높은 비트로 두면 커널이 복잡해지므로, 대신 그 채널의 가중치에 1보다 큰 스케일을 곱하고 같은 채널로 들어오는 활성값은 그 스케일로 나눕니다. 둘을 곱한 출력은 그대로인데, 키운 가중치는 반올림할 때 상대 오차가 작아집니다. 스케일은 보정 데이터의 활성값 통계로 정하고 역전파는 쓰지 않습니다. 저장하는 것은 4비트 가중치와 스케일이라 AWQ도 가중치만 양자화하는 PTQ이고, 저장 형식이 같으면 GPTQ 파일과 크기가 거의 같습니다.

GGUF는 알고리즘이 아니라 파일 형식입니다. 모델을 불러오는 데 필요한 정보를 한 파일에 모두 넣고 mmap으로 바로 읽게 만든 형식입니다. 그 안의 양자화 타입 이름은 규칙이 있습니다. Q4_K_M의 Q4는 4비트 계열, K는 k-quant 방식, 끝의 S·M·L은 더 높은 비트로 남기는 텐서의 양입니다. Llama 3.1 8B에서 Q3_K는 S 3.64, M 4.00, L 4.30 bpw였습니다. `--imatrix`로 보정 데이터에서 구한 중요도 행렬을 넣으면 같은 타입에서 오차를 더 줄일 수 있습니다.

FP8은 정수가 아니라 부동소수점이라 값의 크기가 들쭉날쭉해도 채널이나 텐서마다 스케일 하나로 버팁니다. 앞의 Llama 3.1 연구도 FP8 W8A8은 보정 데이터 없이 반올림만으로 만들었습니다. FP8 형식을 제안한 논문은 가중치와 활성값에 정밀도가 높은 E4M3를, 범위가 넓은 E5M2는 학습 중 기울기에 쓰라고 권합니다. MXFP4와 NVFP4는 같은 4비트 부동소수점(E2M1, 값 범위 약 ±6)에 묶음 스케일을 붙인 형식이고, NVFP4가 묶음을 16개로 줄이고 스케일을 FP8로 둬서 오차를 더 줄인 쪽입니다.

## 무엇을 잃는지는 모델 크기와 과제가 정합니다

“4비트면 몇 % 손실”이라는 숫자는 모델 크기와 과제를 빼면 쓸 수 없습니다. 조건이 가장 잘 정리된 공개 측정은 Kurtic 등이 Llama 3.1 Instruct 8B·70B·405B를 세 형식으로 바꿔 50만 번 넘게 평가한 연구입니다. 아래는 비교적 어려운 과제를 모은 Open LLM Leaderboard V2의 평균 점수를 BF16 모델의 평균 점수와 견준 비율입니다. 점수는 과제마다 무작위로 찍었을 때의 기준선을 빼고 0-100으로 환산한 뒤 평균한 값이라, 96.1은 답의 96.1%를 맞혔다는 뜻이 아니라 평균 점수가 원본의 96.1% 수준이라는 뜻입니다.

| 모델 | FP8 W8A8 | INT8 W8A8 | INT4 W4A16(GPTQ) |
| --- | --- | --- | --- |
| Llama 3.1 8B | 101.2 | 101.5 | 96.1 |
| Llama 3.1 70B | 100.0 | 97.3 | 97.4 |
| Llama 3.1 405B | 99.9 | 98.3 | 98.9 |

*Kurtic et al., arXiv 2411.02355 v4 표 3. W4A16은 GPTQ(그룹 128, MSE 기준 clipping, OpenPlatypus 보정 데이터), INT8 70B는 SmoothQuant를 함께 썼습니다. 분모는 BF16 모델의 정규화된 V2 평균 점수이고, 100을 넘는 값은 양자화 모델의 평균이 원본보다 조금 높게 나온 경우입니다.*

![Open LLM Leaderboard V2 점수 회복률 묶음 막대(BF16 정규화 평균 점수 = 100, 막대는 90부터). 8B는 FP8 101.2, INT8 101.5, INT4 96.1. 70B는 FP8 100.0, INT8 97.3, INT4 97.4. 405B는 FP8 99.9, INT8 98.3, INT4 98.9](https://doyouknow.kr/wp-content/uploads/2026/11/xllm-quantization-guide2-quality.webp.pagespeed.ic.s2oJ1q8ofY.webp)

FP8은 세 크기 모두 100 안팎이었고, INT4는 8B에서 가장 낮았습니다

쉬운 과제 묶음(V1)에서는 세 형식 모두 98.7 이상이었습니다. 같은 연구는 추론용으로 증류한 DeepSeek-R1-Distill 모델도 AIME·MATH-500·GPQA로 쟀습니다.

| DeepSeek-R1-Distill 모델 | INT4 W4A16(BF16 평균 = 100) |
| --- | --- |
| Qwen 1.5B | 93.5 |
| Qwen 7B | 98.3 |
| Llama 8B | 97.2 |
| Qwen 14B | 99.0 |
| Qwen 32B | 99.5 |
| Llama 70B | 98.3 |

![DeepSeek-R1-Distill 모델의 추론 과제(AIME·MATH-500·GPQA 평균) INT4 W4A16 회복률 막대(BF16 = 100, 막대는 90부터). Qwen 1.5B 93.5, Qwen 7B 98.3, Llama 8B 97.2, Qwen 14B 99.0, Qwen 32B 99.5, Llama 70B 98.3](https://doyouknow.kr/wp-content/uploads/2026/11/xllm-quantization-guide2-r1-distill.webp.pagespeed.ic.wsUWViKoH-.webp)

1.5B만 크게 떨어졌고, 7B 이상은 97-99.5였습니다

FP8은 크기와 상관없이 거의 잃지 않았고, 가중치만 양자화한 4비트에서 **가장 많이 잃은 것은 두 평가 모두 가장 작은 모델**이었습니다(V2의 8B 96.1, R1-Distill의 1.5B 93.5). 7B 이상에서는 크기 순서대로 줄지 않아서, 32B가 99.5로 70B의 98.3보다 높았습니다.

GPTQ와 AWQ도 이 연구가 따로 비교했습니다. 학술 벤치마크(Leaderboard V1·V2) 평균에서는 AWQ가 8B에서 0.23점, 70B에서 0.35점 앞서 거의 같았고, 실사용 과제(Arena-Hard·HumanEval·MBPP) 평균에서는 GPTQ가 8B에서 2.9점, 70B에서 0.8점 앞섰습니다. AWQ 논문을 비롯한 앞선 연구에서는 AWQ가 앞서거나 비슷했습니다. 연구진은 이번 GPTQ에 MSE 기준 clipping을 썼고, 기본값(C4)보다 나은 보정 데이터를 썼고, 실사용 과제까지 평가했다는 점을 결과가 달라진 까닭으로 꼽습니다.

제조사 모델 카드의 값도 같은 방향입니다. NVIDIA Qwen3.8 FP4-Local 카드는 GPQA Diamond가 BF16 92.2%에서 FP4 91.5%로, ToolEvalBench가 89.4%에서 88.7%로 내려갔다고 적고 있습니다. llama.cpp 쪽은 이런 과제 점수 대신 원본 모델과의 차이를 perplexity(퍼플렉서티)와 KL divergence(KL 발산)로 잽니다. perplexity가 조금 올랐다는 것만으로는 내 과제의 답이 바뀌었는지 알 수 없습니다.

## 4비트가 항상 더 빠르지는 않습니다

작은 배치로 돌리는 밀집(dense) 모델은 답을 한 토큰씩 만드는 생성(decode) 단계에서 토큰 하나마다 가중치 전체를 메모리에서 읽어 와야 해서, 연산보다 메모리 대역폭이 속도를 정합니다. MoE 모델은 그 토큰에 쓰이는 전문가의 가중치만 읽습니다. 가중치가 4분의 1이 되면 읽을 양도 4분의 1이라 생성이 빨라집니다. 반대로 입력 전체를 한 번에 처리하는 입력 처리(prefill) 단계는 연산량이 많아서, 가중치를 16비트로 되돌리는 비용이 그대로 드러납니다. 작은 배치의 생성 단계가 메모리 대역폭에 묶이는 이야기는 [Speculative Decoding 글](https://doyouknow.kr/speculative-decoding-draft-verify-performance/)
에도 나옵니다.

llama.cpp README의 Llama 3.1 8B 측정이 두 단계의 차이를 그대로 보여 줍니다.

| 형식 | bpw | 크기 | 입력 처리(512토큰) | 생성(128토큰) |
| --- | --- | --- | --- | --- |
| F16 | 16.0 | 14.96GiB | 923.5 tok/s | 29.2 tok/s |
| Q8_0 | 8.5 | 7.95GiB | 865.1 tok/s | 50.9 tok/s |
| Q4_K_M | 4.89 | 4.58GiB | 821.8 tok/s | 71.9 tok/s |

*llama.cpp `tools/quantize` README(2026-11-21 확인). README는 측정 하드웨어를 밝히지 않았고, 표의 값은 형식만 바꿔 잰 한 묶음의 측정입니다.*

![Llama 3.1 8B의 llama.cpp 형식별 속도 두 패널. 생성(128토큰)은 F16 29.2, Q8_0 50.9, Q4_K_M 71.9 tok/s로 Q4_K_M이 가장 빠르고, 입력 처리(512토큰)는 F16 923.5, Q8_0 865.1, Q4_K_M 821.8 tok/s로 F16이 가장 빠르다](https://doyouknow.kr/wp-content/uploads/2026/11/xllm-quantization-guide2-speed.webp.pagespeed.ic.O1qhRyeevM.webp)

생성은 4비트가, 입력 처리는 16비트가 가장 빨랐습니다

생성 속도는 **Q4_K_M이 F16의 2.5배**였지만, 입력 처리는 F16이 가장 빨랐습니다. 긴 문서를 넣고 짧게 답하는 RAG(Retrieval-Augmented Generation, 검색한 문서를 함께 넣어 답하는 방식) 같은 작업은 4비트로 바꿔도 체감 속도가 덜 오릅니다.

요청을 여러 개 묶어 처리하는 서버에서는 계산이 또 달라집니다. 앞의 Llama 3.1 연구가 vLLM으로 잰 값입니다.

| 배포·과제 | 모델·GPU | 지표 | BF16 | 8비트 | INT4 |
| --- | --- | --- | --- | --- | --- |
| 동기, 코드 완성(입력 256·출력 1,024토큰) | 8B · A6000 1장 | 지연 | 24.5초 | INT8 15.9초 | 9.7초 |
| 비동기, 일곱 과제 종합 | 70B · A100 4장 | BF16 대비 처리량 | 1배 | INT8 1.87배 | 1.64배 |
| 비동기, 일곱 과제 종합 | 70B · H100 4장 | BF16 대비 처리량 | 1배 | FP8 1.77배 | 1.55배 |
| 비동기, 코드 독스트링 생성(입력 768·출력 128토큰) | 70B · A100 4장 | 초당 처리 요청 | 6.9건 | INT8 15.9건 | 22.8건 |

*Kurtic et al., arXiv 2411.02355 v4 5절. 동기는 요청을 하나씩 처리하고, 비동기는 요청을 계속 묶어 처리(continuous batching)하는 배포입니다.*

![vLLM 서버 형식별 성능 두 패널. 요청을 하나씩 처리하는 동기 배포에서 Llama 3.1 8B(A6000 1장) 코드 완성 지연은 BF16 24.5초, INT8 15.9초, INT4 9.7초. 요청을 계속 묶는 비동기 배포에서 70B(4장)의 일곱 과제 종합 처리량은 BF16 대비 A100에서 INT8 1.87배, INT4 1.64배, H100에서 FP8 1.77배, INT4 1.55배](https://doyouknow.kr/wp-content/uploads/2026/11/xllm-quantization-guide2-server.webp.pagespeed.ic.gC55I4hx2o.webp)

하나씩 처리하면 4비트가, 계속 묶으면 이 구성에서는 8비트가 앞섰습니다

요청을 하나씩 처리하면 시간 대부분이 생성 단계라 4비트가 가장 빨랐습니다. 요청을 계속 묶으면 70B를 A100·H100 네 장에 올린 일곱 과제 종합에서는 8비트가 4비트를 앞섰습니다. 다만 같은 연구에서 70B를 A6000 네 장에(INT8 1.91배, INT4 1.92배), 405B를 H100 16장에(FP8 3.04배, INT4 3.09배) 올렸을 때는 둘이 거의 같아서, 순위는 GPU와 모델에 따라 바뀝니다. 배치가 커지면 생성 단계도 연산이 많아지고, 그때는 활성값까지 8비트로 계산하는 W8A8이 유리해집니다.

종합 순서가 과제마다 그대로 이어지지는 않습니다. 같은 A100 네 장에서 코드 독스트링 생성은 INT4가 초당 22.8건으로 INT8의 15.9건보다 많았습니다. 4비트 커널 Marlin의 논문은 행렬 곱셈 커널만 따로 재면 FP16 대비 이론상 최대치인 4배에 가까운 속도가 배치 16-32까지 유지되고, 64-128에서는 차츰 줄어든다고 보고합니다. 서버 전체 처리량의 배율은 위 표처럼 그보다 작습니다.

GPU가 그 형식을 계산하지 못하면 이득이 사라지기도 합니다. vLLM은 W8A8 체크포인트를 받았는데 그 GPU에 맞는 활성값 양자화 커널이 없으면, 가중치만 8비트로 두고 활성값은 16비트로 계산하는 커널로 자동으로 바꿉니다. 정확도는 그대로지만 기대한 입력 처리 속도는 나오지 않고, 로그에 경고가 한 번 남습니다. `VLLM_STRICT_QUANT_SCHEME=1`을 주면 이 대체를 막을 수 있습니다.

## 엔진과 GPU를 먼저 정하고 비트 수를 고릅니다

어느 형식이 가장 좋으냐보다, 쓰려는 엔진과 GPU가 무엇을 빠르게 돌리느냐가 먼저입니다. 아래 순서로 좁히면 대부분 두세 개 후보로 줄어듭니다.

![양자화 형식 선택 흐름 두 단계. 1단계 어떻게 돌리나: 혼자·소수가 로컬에서 llama.cpp·Ollama로 돌리면(Mac·CPU·GPU 여러 장 모두) GGUF Q4_K_M부터, 여유 있으면 Q5_K_M 이상. 여러 요청을 받는 서버는 GPU 세대별로 Ampere(A100 등)는 INT8 W8A8·W4A16, Ada·Hopper(L40S·H100 등)는 FP8 W8A8부터, Blackwell은 NVFP4·MXFP4. 2단계 가중치와 KV cache가 메모리에 들어가나: 들어가면 품질·첫 토큰 시간·처리량을 내 과제로 원본과 비교, KV cache가 넘치면 문맥·동시 요청을 줄이거나 엔진이 지원하는 KV cache 양자화, 가중치부터 넘치면 더 낮은 비트·작은 모델·GPU 추가를 비교](https://doyouknow.kr/wp-content/uploads/2026/11/xllm-quantization-guide2-choose.webp.pagespeed.ic.85bcDN6O_r.webp)

엔진과 GPU로 출발점을 정하고, 메모리에 들어가는지로 다음 수를 고릅니다

| 실행 환경 | 현실적인 출발점 | 확인한 사실(2026-11-21) |
| --- | --- | --- |
| 혼자·소수가 로컬에서: Mac(Apple Silicon), CPU | llama.cpp·Ollama + GGUF Q4_K_M | macOS 빌드는 Metal로 GPU 연산이 기본. vLLM 표에서 Arm CPU는 GPTQ·AWQ 미지원 |
| 소비자 NVIDIA GPU(Turing-Ada) 한 장 이상 | llama.cpp로 혼자 쓰면 GGUF, vLLM 서버로 띄우면 GPTQ·AWQ 4비트 | vLLM의 Marlin(GPTQ·AWQ·FP8·FP4 가중치 커널)은 Turing-Hopper 지원 |
| Ampere 데이터센터 GPU | INT8 W8A8, 메모리가 모자라면 W4A16 | vLLM의 FP8 W8A8 지원 표에 Ampere 없음(Ada·Hopper·AMD GPU만) |
| Ada·Hopper 데이터센터 GPU | FP8 W8A8 | 동기 지연이 중요하면 W4A16도 비교 |
| Blackwell(DGX Spark 포함) | 모델 제공사가 낸 NVFP4 체크포인트 | 5세대 Tensor Core가 NVFP4·MXFP4를 계산. 일부 체크포인트는 공식 vLLM이 아닌 전용 컨테이너가 필요 |

*CPU·Turing-Hopper 행의 vLLM 지원 여부는 docs.vllm.ai Quantization 문서(2026-11-17 갱신본)의 하드웨어 표에, Mac의 Metal 기본 사용은 llama.cpp 빌드 문서에 있습니다. Blackwell이 NVFP4·MXFP4를 계산한다는 것은 NVIDIA NVFP4 기술 블로그에, 전용 컨테이너가 필요하다는 것은 Qwen3.8 FP4-Local 모델 카드에 나옵니다.*

몇 가지 함정이 있습니다. vLLM도 GGUF를 읽지만 공식 문서가 “매우 실험적이고 최적화가 덜 됐다”고 적고 있고 별도 플러그인이 필요합니다. 서버에서는 safetensors 계열 체크포인트가 무난합니다. Ollama는 GGUF를 가져올 때 양자화를 해 주지 않으므로, 원하는 타입이 없으면 `llama-quantize`로 직접 만든 뒤 `Modelfile`의 `FROM`에 지정합니다. DGX Spark의 Qwen3.8 FP4-Local처럼 스케일을 새 압축 형식으로 저장한 체크포인트는 모델 카드가 지정한 컨테이너에서만 돌아갔습니다.

llama.cpp `tools/quantize` README(2026-11-21 확인)에 나온 명령 형식은 이렇습니다. 파일 이름은 자기 모델에 맞게 바꿉니다.

후보를 정했으면 네 가지를 확인합니다.

1. 파일 목록에서 실제 크기를 보고 KV cache를 더해 메모리에 들어가는지 계산합니다.
2. 엔진 시작 로그에서 의도한 커널이 잡혔는지, 대체 경고가 없는지 봅니다.
3. 실제 입력·출력 길이와 동시 요청 수로 첫 토큰까지의 시간과 처리량을 원본(또는 8비트)과 비교합니다.
4. 실제로 쓸 프롬프트 몇십 개를 두 모델에 똑같이 넣어 답을 비교합니다. 공개 평가의 평균이 원본과 비슷해도 한국어 응답, 도구 호출, 긴 문서 요약처럼 자주 쓰는 과제에서는 결과가 다를 수 있어서, 비교할 프롬프트도 그런 과제로 고릅니다.

메모리가 넉넉하면 8비트, 모자라면 4비트로 내립니다. 모델 크기와 비트 수를 맞바꿔야 할 때는 같은 메모리 예산에 들어가는 두 후보를 내 과제로 돌려 보고 고릅니다. 앞의 연구에서는 Llama 3.1 70B 4비트의 V2 평균이 40.6점으로 8B 원본의 27.6점보다 한참 높았습니다. 4비트로도 들어가지 않아 3비트 이하로 더 내릴지, 한 단계 작은 모델을 쓸지도 같은 방식으로 정합니다.

## 참고 자료

- [llama.cpp tools/quantize README](https://github.com/ggml-org/llama.cpp/blob/master/tools/quantize/README.md)
- [GGUF 사양(ggml docs/gguf.md)](https://github.com/ggml-org/ggml/blob/master/docs/gguf.md)
- [Frantar et al., GPTQ: Accurate Post-Training Quantization for Generative Pre-trained Transformers](https://arxiv.org/abs/2210.17323)
- [Lin et al., AWQ: Activation-aware Weight Quantization for LLM Compression and Acceleration](https://arxiv.org/abs/2306.00978)
- [Kurtic et al., “Give Me BF16 or Give Me Death”? Accuracy-Performance Trade-Offs in LLM Quantization](https://arxiv.org/abs/2411.02355)
- [Micikevicius et al., FP8 Formats for Deep Learning](https://arxiv.org/abs/2209.05433)
- [NVIDIA Technical Blog, Introducing NVFP4 for Efficient and Accurate Low-Precision Inference](https://developer.nvidia.com/blog/introducing-nvfp4-for-efficient-and-accurate-low-precision-inference/)
- [Frantar et al., MARLIN: Mixed-Precision Auto-Regressive Parallel Inference on Large Language Models](https://arxiv.org/abs/2408.11743)
- [vLLM 문서: Quantization](https://docs.vllm.ai/en/latest/features/quantization/) , [GGUF](https://docs.vllm.ai/en/latest/features/quantization/gguf/)
- [Ollama 문서: Importing a Model](https://github.com/ollama/ollama/blob/main/docs/import.mdx)
- [openai/gpt-oss-120b 모델 카드](https://huggingface.co/openai/gpt-oss-120b)
- [nvidia/Qwen3.8-Flash-Next-FP4-Local 모델 카드](https://huggingface.co/nvidia/Qwen3.8-Flash-Next-FP4-Local)

### 관련된 글:

1. [sLLM 완벽 가이드: 작은 고추가 맵다! 온디바이스 AI의 미래를 열다](https://doyouknow.kr/sllm-guide-small-language-model-on-device-ai/)
2. [DGX Spark(GB10), 1,200만 원 주고 살 만할까? 한 대로 사내 AI를 돌려 본 실측 기록](https://doyouknow.kr/dgx-spark-gb10-worth-it/)
3. [NVIDIA PAIR는 여러 PC를 어떻게 묶을까? 로컬 AI 요청 분산의 구조와 한계](https://doyouknow.kr/nvidia-pair-local-ai-request-routing/)
4. [소형 AI 모델 혁명: SLM과 온디바이스 AI가 바꾸는 미래 – 클라우드 없이 스마트폰에서 GPT급 AI를!](https://doyouknow.kr/slm-small-language-model-ondevice-ai-guide/)

### 답글 남기기 [응답 취소](/llm-quantization-gptq-awq-gguf-pruning-distillation-guide2/?t=1795353411#respond)
