13_quantization_example.py

  1"""
  213. 모델 양자화 (Model Quantization) 예제
  3
  4INT8/INT4 양자화, bitsandbytes, GPTQ, AWQ 실습
  5"""
  6
  7import numpy as np
  8
  9print("=" * 60)
 10print("모델 양자화 (Model Quantization)")
 11print("=" * 60)
 12
 13
 14# ============================================
 15# 1. 기본 양자화 이해
 16# ============================================
 17print("\n[1] 기본 양자화 개념")
 18print("-" * 40)
 19
 20def quantize_symmetric(tensor, bits=8):
 21    """대칭 양자화 (Symmetric Quantization)"""
 22    qmin = -(2 ** (bits - 1))
 23    qmax = 2 ** (bits - 1) - 1
 24
 25    # 스케일 계산
 26    abs_max = np.abs(tensor).max()
 27    scale = abs_max / qmax if abs_max != 0 else 1.0
 28
 29    # 양자화
 30    quantized = np.round(tensor / scale).astype(np.int8)
 31    quantized = np.clip(quantized, qmin, qmax)
 32
 33    return quantized, scale
 34
 35def dequantize(quantized, scale):
 36    """역양자화"""
 37    return quantized.astype(np.float32) * scale
 38
 39
 40# 테스트
 41original = np.array([0.5, -1.2, 0.3, 2.1, -0.8, 0.0], dtype=np.float32)
 42print(f"원본 텐서: {original}")
 43
 44quantized, scale = quantize_symmetric(original, bits=8)
 45print(f"양자화됨 (INT8): {quantized}")
 46print(f"스케일: {scale:.6f}")
 47
 48recovered = dequantize(quantized, scale)
 49print(f"복원됨: {recovered}")
 50
 51error = np.abs(original - recovered).mean()
 52print(f"평균 양자화 오차: {error:.6f}")
 53
 54
 55# ============================================
 56# 2. 비대칭 양자화
 57# ============================================
 58print("\n[2] 비대칭 양자화")
 59print("-" * 40)
 60
 61def quantize_asymmetric(tensor, bits=8):
 62    """비대칭 양자화 (Asymmetric Quantization)"""
 63    qmin = 0
 64    qmax = 2 ** bits - 1
 65
 66    min_val = tensor.min()
 67    max_val = tensor.max()
 68
 69    scale = (max_val - min_val) / (qmax - qmin) if max_val != min_val else 1.0
 70    zero_point = round(-min_val / scale) if scale != 0 else 0
 71
 72    quantized = np.round(tensor / scale + zero_point).astype(np.uint8)
 73    quantized = np.clip(quantized, qmin, qmax)
 74
 75    return quantized, scale, zero_point
 76
 77def dequantize_asymmetric(quantized, scale, zero_point):
 78    """비대칭 역양자화"""
 79    return (quantized.astype(np.float32) - zero_point) * scale
 80
 81
 82# 테스트
 83asym_quantized, asym_scale, zero_point = quantize_asymmetric(original, bits=8)
 84print(f"비대칭 양자화 (UINT8): {asym_quantized}")
 85print(f"스케일: {asym_scale:.6f}, Zero Point: {zero_point}")
 86
 87asym_recovered = dequantize_asymmetric(asym_quantized, asym_scale, zero_point)
 88print(f"복원됨: {asym_recovered}")
 89
 90
 91# ============================================
 92# 3. 그룹별 양자화
 93# ============================================
 94print("\n[3] 그룹별 양자화 (Group Quantization)")
 95print("-" * 40)
 96
 97def group_quantize(tensor, group_size=4, bits=4):
 98    """그룹별 양자화 - 정확도 향상"""
 99    flat = tensor.flatten()
100    pad_size = (group_size - len(flat) % group_size) % group_size
101    if pad_size > 0:
102        flat = np.pad(flat, (0, pad_size))
103
104    groups = flat.reshape(-1, group_size)
105    quantized_groups = []
106    scales = []
107
108    qmax = 2 ** (bits - 1) - 1
109    qmin = -(2 ** (bits - 1))
110
111    for group in groups:
112        abs_max = np.abs(group).max()
113        scale = abs_max / qmax if abs_max != 0 else 1.0
114        q = np.round(group / scale).astype(np.int8)
115        q = np.clip(q, qmin, qmax)
116        quantized_groups.append(q)
117        scales.append(scale)
118
119    return np.array(quantized_groups), np.array(scales)
120
121def group_dequantize(quantized_groups, scales):
122    """그룹별 역양자화"""
123    recovered = []
124    for q, s in zip(quantized_groups, scales):
125        recovered.append(q.astype(np.float32) * s)
126    return np.concatenate(recovered)
127
128
129# 테스트
130larger_tensor = np.random.randn(16).astype(np.float32)
131print(f"원본 (16개): {larger_tensor[:8]}...")
132
133g_quantized, g_scales = group_quantize(larger_tensor, group_size=4, bits=4)
134print(f"그룹 수: {len(g_scales)}, 그룹 크기: 4")
135print(f"스케일들: {g_scales}")
136
137g_recovered = group_dequantize(g_quantized, g_scales)
138g_error = np.abs(larger_tensor - g_recovered).mean()
139print(f"그룹 양자화 평균 오차: {g_error:.6f}")
140
141
142# ============================================
143# 4. 비트 정밀도 비교
144# ============================================
145print("\n[4] 비트 정밀도 비교")
146print("-" * 40)
147
148def compare_bit_precision(tensor):
149    """다양한 비트 정밀도 비교"""
150    results = {}
151
152    for bits in [8, 4, 2]:
153        q, s = quantize_symmetric(tensor, bits=bits)
154        r = dequantize(q, s)
155        error = np.abs(tensor - r).mean()
156        results[f"INT{bits}"] = {
157            "error": error,
158            "range": (-(2**(bits-1)), 2**(bits-1)-1)
159        }
160
161    return results
162
163comparison = compare_bit_precision(original)
164print("비트별 양자화 비교:")
165for name, result in comparison.items():
166    print(f"  {name}: 오차={result['error']:.6f}, 범위={result['range']}")
167
168
169# ============================================
170# 5. bitsandbytes 예제 (코드만)
171# ============================================
172print("\n[5] bitsandbytes 사용법 (코드 예시)")
173print("-" * 40)
174
175bnb_code = '''
176# bitsandbytes 8비트 양자화
177from transformers import AutoModelForCausalLM, AutoTokenizer
178
179model_8bit = AutoModelForCausalLM.from_pretrained(
180    "meta-llama/Llama-2-7b-hf",
181    load_in_8bit=True,
182    device_map="auto"
183)
184
185# bitsandbytes 4비트 양자화 (NF4)
186from transformers import BitsAndBytesConfig
187import torch
188
189bnb_config = BitsAndBytesConfig(
190    load_in_4bit=True,
191    bnb_4bit_quant_type="nf4",           # Normal Float 4
192    bnb_4bit_compute_dtype=torch.bfloat16,
193    bnb_4bit_use_double_quant=True       # 이중 양자화
194)
195
196model_4bit = AutoModelForCausalLM.from_pretrained(
197    "meta-llama/Llama-2-7b-hf",
198    quantization_config=bnb_config,
199    device_map="auto"
200)
201
202print(f"4bit 모델 메모리: {model_4bit.get_memory_footprint() / 1e9:.2f} GB")
203'''
204print(bnb_code)
205
206
207# ============================================
208# 6. GPTQ 예제 (코드만)
209# ============================================
210print("\n[6] GPTQ 양자화 (코드 예시)")
211print("-" * 40)
212
213gptq_code = '''
214from transformers import AutoModelForCausalLM, AutoTokenizer, GPTQConfig
215
216# GPTQ 설정
217gptq_config = GPTQConfig(
218    bits=4,
219    group_size=128,
220    desc_act=True,
221    dataset=calibration_data,
222    tokenizer=tokenizer
223)
224
225# 양자화
226model = AutoModelForCausalLM.from_pretrained(
227    "meta-llama/Llama-2-7b-hf",
228    quantization_config=gptq_config,
229    device_map="auto"
230)
231
232model.save_pretrained("./llama-2-7b-gptq-4bit")
233
234# 사전 양자화 모델 로드
235model = AutoModelForCausalLM.from_pretrained(
236    "TheBloke/Llama-2-7B-GPTQ",
237    device_map="auto"
238)
239'''
240print(gptq_code)
241
242
243# ============================================
244# 7. AWQ 예제 (코드만)
245# ============================================
246print("\n[7] AWQ 양자화 (코드 예시)")
247print("-" * 40)
248
249awq_code = '''
250from awq import AutoAWQForCausalLM
251from transformers import AutoTokenizer
252
253# 모델 로드
254model = AutoAWQForCausalLM.from_pretrained("meta-llama/Llama-2-7b-hf")
255tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-2-7b-hf")
256
257# AWQ 양자화 설정
258quant_config = {
259    "zero_point": True,
260    "q_group_size": 128,
261    "w_bit": 4,
262    "version": "GEMM"
263}
264
265# 양자화
266model.quantize(tokenizer, quant_config=quant_config)
267model.save_quantized("./llama-2-7b-awq")
268
269# AWQ 모델 추론
270model = AutoAWQForCausalLM.from_quantized(
271    "./llama-2-7b-awq",
272    fuse_layers=True  # 레이어 퓨전으로 속도 향상
273)
274'''
275print(awq_code)
276
277
278# ============================================
279# 8. QLoRA 예제 (코드만)
280# ============================================
281print("\n[8] QLoRA 파인튜닝 (코드 예시)")
282print("-" * 40)
283
284qlora_code = '''
285from transformers import AutoModelForCausalLM, BitsAndBytesConfig
286from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
287import torch
288
289# 4비트 양자화 설정
290bnb_config = BitsAndBytesConfig(
291    load_in_4bit=True,
292    bnb_4bit_quant_type="nf4",
293    bnb_4bit_compute_dtype=torch.bfloat16,
294    bnb_4bit_use_double_quant=True
295)
296
297# 모델 로드
298model = AutoModelForCausalLM.from_pretrained(
299    "meta-llama/Llama-2-7b-hf",
300    quantization_config=bnb_config,
301    device_map="auto"
302)
303
304# k-bit 학습 준비
305model = prepare_model_for_kbit_training(model)
306
307# LoRA 설정
308lora_config = LoraConfig(
309    r=16,
310    lora_alpha=32,
311    target_modules=["q_proj", "k_proj", "v_proj", "o_proj"],
312    lora_dropout=0.05,
313    bias="none",
314    task_type="CAUSAL_LM"
315)
316
317# LoRA 적용
318model = get_peft_model(model, lora_config)
319model.print_trainable_parameters()
320# 출력: trainable params: ~0.1%
321'''
322print(qlora_code)
323
324
325# ============================================
326# 9. 양자화 메모리 절약 시뮬레이션
327# ============================================
328print("\n[9] 양자화 메모리 절약 시뮬레이션")
329print("-" * 40)
330
331def estimate_model_size(params_billions, bits):
332    """모델 크기 추정 (GB)"""
333    bytes_per_param = bits / 8
334    size_gb = params_billions * 1e9 * bytes_per_param / (1024**3)
335    return size_gb
336
337model_sizes = {
338    "7B": 7,
339    "13B": 13,
340    "70B": 70,
341}
342
343precisions = {
344    "FP32": 32,
345    "FP16": 16,
346    "INT8": 8,
347    "INT4": 4,
348}
349
350print("모델 크기 추정 (GB):")
351print("-" * 60)
352header = "Model\t" + "\t".join(precisions.keys())
353print(header)
354print("-" * 60)
355
356for model_name, params in model_sizes.items():
357    sizes = [f"{estimate_model_size(params, bits):.1f}" for bits in precisions.values()]
358    print(f"{model_name}\t" + "\t".join(sizes))
359
360
361# ============================================
362# 정리
363# ============================================
364print("\n" + "=" * 60)
365print("양자화 정리")
366print("=" * 60)
367
368summary = """
369양자화 핵심 개념:
370
3711. 대칭 양자화:
372   - scale = max(|x|) / (2^(bits-1) - 1)
373   - x_q = round(x / scale)
374   - x' = x_q * scale
375
3762. 비대칭 양자화:
377   - scale = (max - min) / (2^bits - 1)
378   - zero_point = round(-min / scale)
379   - x_q = round(x / scale + zero_point)
380
3813. 양자화 방법 비교:
382   - bitsandbytes: 빠른 적용, 동적 양자화
383   - GPTQ: 높은 품질, 캘리브레이션 필요
384   - AWQ: 빠른 양자화, 활성화 기반
385   - QLoRA: 양자화 + LoRA 파인튜닝
386
3874. 선택 가이드:
388   - 프로토타이핑: bitsandbytes (load_in_8bit)
389   - 메모리 제한: bitsandbytes (load_in_4bit)
390   - 프로덕션: GPTQ 또는 AWQ
391   - 파인튜닝: QLoRA
392"""
393print(summary)