LLM 양자화 (Quantization) 가이드

목차

1. 양자화란 무엇인가?
2. 왜 양자화가 필요한가?
3. 양자화 동작 원리 — 상세 설명
4. 양자화 후에도 품질이 유지되는 이유
5. 양자화 방식 비교 — GPTQ, GGUF, AWQ
6. 양자화의 활용 범위
7. 실전 가이드 — 용도별 선택 기준

---

1. 양자화란 무엇인가?

1.1 한 줄 정의

양자화(Quantization) = 모델 가중치의 정밀도를 낮춰서(비트 수를 줄여서) 모델 크기를 압축하는 기법.

1.2 양자역학과의 관계

이름만 빌려온 것이며, 직접적인 관계는 없다. 공통점은 “연속적인 값을 불연속적(이산적) 값으로 바꾼다” 는 개념 하나뿐이다.

	양자역학	AI 양자화
대상	전자의 에너지 준위	모델 파라미터(가중치)
의미	에너지가 연속이 아닌 띄엄띄엄 존재	실수값을 적은 비트로 근사
관계	물리 법칙	용어만 차용한 공학적 압축 기법

1.3 비유

JPEG 사진 압축과 동일한 원리다:

• 원본 사진(10MB) → JPEG 압축(1MB) → 눈으로 보면 거의 같음
• FP32 모델(280GB) → INT4 양자화(35GB) → 성능 거의 같음

핵심 정보는 유지하면서 용량을 줄이는 것이 양자화의 본질이다.

---

2. 왜 양자화가 필요한가?

2.1 LLM의 메모리 문제

LLM의 파라미터는 기본적으로 32비트 부동소수점(FP32) 으로 저장된다.

Llama 3 70B 모델 기준:
파라미터 수: 700억 개
각 파라미터: 32비트(4바이트) 부동소수점
필요 메모리: 70,000,000,000 × 4 bytes = 280 GB
→ 일반 GPU(24GB VRAM)로는 실행 불가능

2.2 양자화 수준별 메모리 비교

양자화	비트	모델 크기	필요 VRAM	일반 GPU로 실행
FP32	32	280 GB	280+ GB	불가능
FP16	16	140 GB	140+ GB	불가능
INT8	8	70 GB	70+ GB	어려움
INT4	4	35 GB	~40 GB	2×24GB로 가능
INT2	2	17.5 GB	~20 GB	단일 24GB 가능

2.3 비용 임팩트

GPT-4급 모델 서빙 비용:
FP32: GPU 100대 필요 → 월 수억 원
INT8: GPU 30대 필요 → 월 수천만 원
INT4: GPU 15대 필요 → 월 수백만 원

개인 사용자:
FP16: "A100 80GB GPU 사야 함" → 2,000만 원
INT4: "RTX 4090 24GB로 가능" → 300만 원
GGUF Q4: "그냥 내 노트북에서 실행" → 0원

---

3. 양자화 동작 원리 — 상세 설명

3.1 전체 프로세스

원본 데이터 (FP32)
│
▼
┌─────────────┐
│ 1. 범위 파악 │  min, max 값 확인
└──────┬──────┘
       │
       ▼
┌─────────────┐
│ 2. 스케일 계산│  연속 범위를 정수 범위에 매핑
└──────┬──────┘
       │
       ▼
┌─────────────┐
│ 3. 양자화    │  실수 → 정수 변환 (반올림)
└──────┬──────┘
       │
       ▼
┌─────────────┐
│ 4. 저장      │  정수 배열 + scale + zero_point
└──────┬──────┘
       │
       ▼
┌─────────────┐
│ 5. 역양자화  │  정수 → 실수 복원 (근사값)
└─────────────┘

3.2 단계별 예시 (FP32 → INT8)

8개의 가중치를 양자화하는 전체 과정:

원본 (FP32):
w = [1.2, -0.5, 0.3, 2.4, -1.8, 0.7, -0.1, 1.5]

1단계: 범위 파악

min(w) = -1.8
max(w) = 2.4
총 범위 = 2.4 - (-1.8) = 4.2

2단계: 스케일(scale)과 영점(zero_point) 계산

INT8의 표현 범위: [0, 255] (부호 없는 8비트 정수, 256단계)

scale = (max - min) / (2^비트수 - 1)
      = 4.2 / 255
      = 0.01647

zero_point = round(-min / scale)
           = round(1.8 / 0.01647)
           = 109

두 값의 의미:

scale = 정수 1단계가 실수로 얼마에 해당하는가 (눈금 간격)
zero_point = 원본의 0.0이 정수로 몇에 해당하는가 (기준점)

실수 축:  -1.8 ───── 0.0 ──────── 2.4
            │         │            │
정수 축:    0 ─────── 109 ──────── 255

3단계: 양자화 (실수 → 정수)

공식: q = round(원본값 / scale) + zero_point

w[0] =  1.2 → round(1.2 / 0.01647) + 109 =  73 + 109 = 182
w[1] = -0.5 → round(-0.5 / 0.01647) + 109 = -30 + 109 =  79
w[2] =  0.3 → round(0.3 / 0.01647) + 109 =  18 + 109 = 127
w[3] =  2.4 → round(2.4 / 0.01647) + 109 = 146 + 109 = 255
w[4] = -1.8 → round(-1.8 / 0.01647) + 109 = -109 + 109 =   0
w[5] =  0.7 → round(0.7 / 0.01647) + 109 =  43 + 109 = 152
w[6] = -0.1 → round(-0.1 / 0.01647) + 109 =  -6 + 109 = 103
w[7] =  1.5 → round(1.5 / 0.01647) + 109 =  91 + 109 = 200

4단계: 저장

양자화된 배열 (INT8): [182, 79, 127, 255, 0, 152, 103, 200]
scale (FP32): 0.01647
zero_point (INT8): 109

메모리 비교:
원본:   8개 × 4바이트(FP32)                        = 32바이트
양자화: 8개 × 1바이트(INT8) + 4바이트(scale) + 1바이트(zp) = 13바이트
→ 실제 모델에서는 수백만 개 가중치가 scale/zp를 공유하므로 약 25%로 압축

5단계: 역양자화 (정수 → 실수 복원)

공식: 복원값 = (양자화값 - zero_point) × scale

q[0] = 182 → (182 - 109) × 0.01647 =  1.2023
q[1] =  79 → (79 - 109)  × 0.01647 = -0.4941
q[2] = 127 → (127 - 109) × 0.01647 =  0.2965
q[3] = 255 → (255 - 109) × 0.01647 =  2.4046
q[4] =   0 → (0 - 109)   × 0.01647 = -1.7952
q[5] = 152 → (152 - 109) × 0.01647 =  0.7082
q[6] = 103 → (103 - 109) × 0.01647 = -0.0988
q[7] = 200 → (200 - 109) × 0.01647 =  1.4988

오차 확인:

원본      복원      오차       오차율
1.2000    1.2023   +0.0023    0.19%
-0.5000  -0.4941   +0.0059    1.18%
0.3000    0.2965   -0.0035    1.17%
2.4000    2.4046   +0.0046    0.19%
-1.8000  -1.7952   +0.0048    0.27%
0.7000    0.7082   +0.0082    1.17%
-0.1000  -0.0988   +0.0012    1.20%
1.5000    1.4988   -0.0012    0.08%

평균 오차율: 약 0.68%

핵심: 완벽한 복원은 불가능하다. 반올림 과정에서 정보가 소실되기 때문이다. 하지만 수십억 개의 오차가 서로 상쇄되면서 전체 모델 성능에는 미미한 영향만 남는다.

3.3 INT4 양자화 — 더 극단적인 압축

같은 데이터를 4비트(16단계)로 줄이면:

INT4 범위: [0, 15] (16단계)
scale = 4.2 / 15 = 0.28
zero_point = round(1.8 / 0.28) = 6

양자화 및 복원 결과:
10 → (10-6) × 0.28 = 1.12    원본 1.2   오차 6.7%
 4 → (4-6)  × 0.28 = -0.56   원본 -0.5  오차 12.0%
 7 → (7-6)  × 0.28 = 0.28    원본 0.3   오차 6.7%
 6 → (6-6)  × 0.28 = 0.00    원본 -0.1  오차 100% ← 0에 가까운 값이 뭉개짐

눈금 간격 비교:
INT8 (256단계): |·|·|·|·|·|·|·|·|·|·|·|·|·|·|·|·|  ← 촘촘함
                간격: 0.01647
INT4 (16단계):  |   ·   |   ·   |   ·   |   ·   |    ← 성김
                간격: 0.28

3.4 그룹 양자화 (Group Quantization)

전체 가중치에 하나의 scale/zero_point를 쓰면, 이상치(outlier)가 정밀도를 깎아먹는 문제가 있다.

문제 상황:
가중치: [0.1, 0.2, 0.15, 0.18, 0.12, 0.22, 0.11, 50.0]
                                                    ↑ 이상치
min=0.1, max=50.0 → scale이 너무 커져서
대부분의 값(0.1~0.22)이 정수 0~1에 몰림 → 구분 불가!

해결: 가중치를 그룹으로 나눠서 각각 양자화

그룹 1: [0.1, 0.2, 0.15, 0.18]  → 이 범위 안에서 정밀하게 양자화
그룹 2: [0.12, 0.22, 0.11, 50.0] → 이상치가 있는 그룹만 정밀도 희생

이것이 GGUF 파일명에서 보이는 K-quant의 원리이다.

3.5 실제 모델에서의 추론 흐름

저장 상태: INT4 가중치 + scale + zero_point (35GB)

입력 토큰: "오늘 날씨"
│
▼
┌─────────────────────────────────────────┐
│ 레이어 1                                 │
│ INT4 가중치 → 역양자화(INT4→FP16)        │
│ → 행렬 곱셈(FP16 연산) → 활성화 함수      │
│ → 다음 레이어로 전달                      │
└─────────────────────────────────────────┘
│
▼ (80개 레이어 반복)
│
▼
출력 토큰: "어때?"

핵심: 가중치는 INT4로 저장만 되고, 실제 계산은 FP16으로 복원해서 수행한다. 저장은 INT4(메모리 절약), 계산은 FP16(정확도 유지).

3.6 양자화 핵심 공식 요약

양자화:   q  = round(x / scale) + zero_point
역양자화: x' = (q - zero_point) × scale

---

4. 양자화 후에도 품질이 유지되는 이유

4.1 실제 성능 하락 수치

양자화	크기 (대비)	정확도 (대비)	체감
FP16 (원본)	100%	100%	기준
INT8	50%	~99%	거의 차이 없음
INT4	25%	~95-97%	미세한 차이
INT3	18.75%	~90-93%	복잡한 추론에서 차이
INT2	12.5%	~80-85%	눈에 띄는 열화

25%로 줄이는데 95%+ 성능이 나온다. 그 이유는 아래 3가지이다.

4.2 원리 1: 오차의 상쇄 (가장 중요)

신경망의 뉴런 하나는 수백~수천 개 가중치의 합으로 계산된다.

출력 = w1×x1 + w2×x2 + w3×x3 + ... + w1000×x1000

FP32: = 0.2384×1.2 + (-0.5172)×0.8 + ... = 1.7432
INT8: = 0.24×1.2   + (-0.52)×0.8   + ... = 1.7389
                                      오차: 0.25%

개별 반올림 오차에서 양(+)과 음(-)이 무작위로 섞여 합산하면 상쇄된다. 이것은 통계학의 대수의 법칙이다. 파라미터가 700억 개나 되니, 개별 오차는 전체에 거의 무영향.

4.3 원리 2: 신경망의 내재적 중복성 (Redundancy)

실험 결과:
FP32 모델의 가중치 중 무작위 50%를 0으로 만들어도
성능이 ~90% 유지됨 (프루닝 연구)

→ 가중치의 상당 부분이 "있으면 좋지만 없어도 되는" 수준
→ 소수점 아래 정밀도는 더더욱 불필요

4.4 원리 3: 활성화 함수가 차이를 흡수

Softmax (최종 출력):
[2.1, 0.3, -1.5] → [0.82, 0.14, 0.02]  ← 원본
[2.0, 0.4, -1.6] → [0.79, 0.16, 0.02]  ← 양자화 후에도 순위 동일

최종 출력에서 중요한 건 "어떤 토큰이 가장 높은 확률인가"이지,
그 확률의 소수점 셋째 자리가 아니다.

4.5 그럼 왜 INT2까지 가면 깨지는가?

INT4 (16단계): ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■
               → 가중치의 "상대적 크기 관계"가 보존됨

INT2 (4단계):  ■       ■       ■       ■
               → 0.23과 0.87이 같은 값으로 합쳐짐
               → 복구 불가능한 정보 손실

4.6 핵심 요약

모델의 성능은 개별 가중치의 정밀도가 아니라 수십억 가중치의 협력 패턴에서 나온다. 양자화는 개별 정밀도를 깎지만, 전체 패턴은 보존하기 때문에 성능이 유지된다.

---

5. 양자화 방식 비교 — GPTQ, GGUF, AWQ

5.1 분류 먼저 명확히

GPTQ → 양자화 "알고리즘" (어떻게 양자화하는가)
AWQ  → 양자화 "알고리즘" (어떻게 양자화하는가)
GGUF → 파일 "포맷" + 자체 양자화 알고리즘

비유:
GPTQ, AWQ = 사진을 압축하는 "알고리즘" (JPEG, WebP)
GGUF      = 압축된 사진을 담는 "파일 형식" (.jpg, .webp)

5.2 GPTQ (2022)

핵심 전략: 양자화 오차를 다음 가중치에 순차 보정

동작 과정:
w1 양자화 → 오차 발생 → w2, w3, w4... 에 보정값 분배
w2 양자화 → 오차 발생 → w3, w4, w5... 에 보정값 분배
...순차적으로 진행

결과: 개별 오차는 있지만, 레이어 전체의 출력 오차가 최소화됨

• 캘리브레이션 데이터 필요 (128~1024개 텍스트 샘플)
• GPU에서 실행 최적화 (cuBLAS, ExLlama 커널)
• 양자화 과정에 GPU 필요, 시간 소요 (수십 분~수 시간)
• GPU 전용 (CPU에서 실행 어려움)

5.3 GGUF (2023)

핵심 전략: 레이어 중요도에 따라 비트를 차등 배분 (K-Quant)

K-Quant 전략 (레이어별 차등 비트):
Attention 레이어 (중요):     6비트 ← 정밀하게
FFN 레이어 (덜 중요):       4비트 ← 과감하게 압축
임베딩 레이어 (매우 중요):   8비트 ← 가장 정밀하게

→ 전체 평균은 ~4.5비트이지만 중요한 부분의 정밀도는 유지

파일명 해석:

Q4_K_S → 평균 4비트, K-quant, Small (더 공격적 압축)
Q4_K_M → 평균 4비트, K-quant, Medium (균형)
Q5_K_M → 평균 5비트, K-quant, Medium
Q8_0   → 8비트, 단순 양자화 (K-quant 아님)
Q2_K   → 평균 2비트, K-quant (품질 많이 떨어짐)

• CPU에서도 실행 가능 (GPU 없어도 됨)
• 단일 파일로 배포 간편 (모델 + 토크나이저 + 설정 통합)
• Apple Silicon(M1/M2/M3) Metal 가속 지원
• 양자화 변환이 빠름 (수 분)
• 캘리브레이션 데이터 불필요
• llama.cpp, Ollama, LM Studio에서 사용

5.4 AWQ (2023)

핵심 전략: 활성화(activation) 값이 큰 채널의 가중치만 선별 보호

AWQ의 발견: 가중치의 1%만 보호해도 성능 대부분 유지됨

동작 과정:
1. 샘플 데이터로 각 채널별 활성화 크기 측정
2. 활성화가 큰 채널 = 중요 = 보호 대상
3. 중요 가중치를 양자화 전에 스케일 업(확대)
   → 양자화 후에도 정밀도 유지
   → 추론 시 다시 스케일 다운

예시:
채널 2 가중치: 0.0023 (아주 작은 값)
그냥 INT4 → 0으로 반올림 → 정보 소실!
스케일 업: 0.0023 × 100 = 0.23 → INT4 → 근사값 유지
추론 시 ÷ 100 → 복원

• 같은 비트 수에서 GPTQ보다 품질 좋은 경우 많음
• 양자화 속도가 매우 빠름
• GPU 전용
• vLLM에서 네이티브 지원 (서빙 최적화)

5.5 기술 비교표

	GPTQ	GGUF (K-Quant)	AWQ
분류	알고리즘	포맷 + 알고리즘	알고리즘
핵심 전략	오차를 다음 가중치에 보정	레이어별 비트 차등 배분	중요 가중치만 정밀도 보호
캘리브레이션	필요 (128+ 샘플)	불필요	필요 (소량)
양자화 속도	느림 (수십 분~수 시간)	빠름 (수 분)	빠름 (수십 분)
실행 환경	GPU 전용	CPU + GPU 모두	GPU 전용
대표 런타임	ExLlamaV2, AutoGPTQ	llama.cpp, Ollama	vLLM, AutoAWQ

5.6 같은 4비트 품질 비교 (벤치마크 일반 경향)

AWQ 4bit     ████████████████████████████░░  ~97%
GPTQ 4bit    ███████████████████████████░░░  ~96%
GGUF Q4_K_M  ██████████████████████████░░░░  ~95%
GGUF Q4_0    █████████████████████████░░░░░  ~93%

차이가 크지 않으며, 실사용에서 체감하기 어려운 수준이다. 선택 기준은 품질보다 실행 환경이 더 중요하다.

---

6. 양자화의 활용 범위

LLM에서만 쓰이는 기법이 아니다. AI 전반과 AI 밖에서도 널리 사용되는 범용 기술이다.

6.1 AI/ML 분야

분야	활용 예시
LLM	GPT-4, Llama, Mistral 등 대규모 모델 압축, 개인 PC 실행
이미지 AI	자율주행 차량의 객체 탐지 모델(YOLO, ResNet)을 INT8로 양자화하여 차량 칩에 탑재
음성 AI	스마트 스피커, 스마트폰의 음성인식 모델을 기기 내에서 실행
추천 시스템	넷플릭스, 유튜브 등 서빙 비용 절감 및 응답 속도 향상

6.2 AI가 아닌 분야

분야	활용 예시
오디오	CD 음질(16비트) vs 전화 음질(8비트), MP3 압축
이미지	True Color(24비트, 1677만 색) → 256색(8비트) → 16색(4비트)
게임	3D 모델 정점 좌표를 FP16으로 줄여 모바일 기기에서 실행
통신	5G 기지국 ADC(아날로그-디지털 변환기)의 신호 양자화

6.3 AI에서 특히 주목받는 이유

다른 분야에서는 양자화가 당연히 쓰이는 기본 기술이라 화제가 안 된다. AI에서 유독 주목받는 이유는 비용 임팩트가 압도적이기 때문이다. 양자화 하나로 수십 배의 비용 차이가 나므로 AI 업계에서 핵심 기술로 부각된다.

---

7. 실전 가이드 — 용도별 선택 기준

7.1 용도별 추천

"GPU 없이 내 노트북/PC에서 돌리고 싶다"
  → GGUF (llama.cpp, Ollama, LM Studio)

"NVIDIA GPU로 최고 품질을 원한다"
  → AWQ 또는 GPTQ

"서버에서 여러 사용자에게 서빙한다"
  → AWQ (vLLM과 조합)

"Apple M1/M2/M3 맥에서 돌린다"
  → GGUF (Metal 가속 지원)

7.2 Hugging Face에서 양자화 모델 식별

TheBloke/Llama-2-70B-GPTQ  ← GPTQ 방식
TheBloke/Llama-2-70B-GGUF  ← GGUF 형식
TheBloke/Llama-2-70B-AWQ   ← AWQ 방식

파일명 예시:
llama-2-70b.Q4_K_M.gguf  ← 4비트, K-quant, Medium
llama-2-70b.Q8_0.gguf    ← 8비트
llama-2-70b.Q2_K.gguf    ← 2비트 (품질 낮음)

7.3 양자화 시기에 따른 분류

방식	설명	특징
PTQ (Post-Training)	훈련 후 양자화 — 이미 훈련된 모델을 사후 변환	빠르고 간단, GPTQ/GGUF/AWQ 모두 해당
QAT (Quantization-Aware Training)	훈련 중 양자화 — 훈련 단계에서부터 양자화 오차 반영	정확도 최상, 하지만 처음부터 다시 훈련 필요