실습 1 — 직접 양자화해 보기

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

name = "Qwen/Qwen2.5-0.5B-Instruct"
tok = AutoTokenizer.from_pretrained(name)
model = AutoModelForCausalLM.from_pretrained(name, dtype=torch.float32)     # CPU, fp32
W = model.model.layers[0].mlp.down_proj.weight.detach().clone()             # 첫 층 MLP 의 한 행렬
n_params = sum(p.numel() for p in model.parameters())
print("모델 파라미터:", f"{n_params:,}", "· 행렬:", tuple(W.shape), f"· fp32 로 {W.numel() * 4 / 1e6:.1f}MB")
# 결과: 가장 큰 절댓값과 99.9% 지점의 절댓값. 둘이 크게 다르면 튀는 값이 있다
print("최대 |w|:", round(W.abs().max().item(), 3), "· 99.9% |w|:", round(W.abs().quantile(0.999).item(), 3))

def quantize(W, bits, group=None, per_row=False):
    """대칭 양자화 뒤 되돌린 행렬을 돌려준다. group 이면 그 크기 묶음마다, per_row 면 행마다 스케일을 둔다"""
    qmax = 2 ** (bits - 1) - 1                                   # int8 이면 127, int4 면 7
    X = W.reshape(W.shape[0], -1, group) if group else W
    if group:
        scale = X.abs().amax(dim=-1, keepdim=True) / qmax        # 묶음마다
    elif per_row:
        scale = X.abs().amax(dim=1, keepdim=True) / qmax         # 행마다
    else:
        scale = X.abs().amax() / qmax                            # 텐서 전체에 하나
    Q = torch.clamp(torch.round(X / scale), -qmax - 1, qmax)     # 반올림해 정수 눈금에 맞춘다
    return (Q * scale).reshape(W.shape)


rows = []
for bits in (8, 4):
    for how, kw in [("텐서마다", {}), ("행마다", {"per_row": True}), ("128개 묶음마다", {"group": 128})]:
        Wq = quantize(W, bits, **kw)
        rel = ((W - Wq).norm() / W.norm()).item()                # 상대 오차
        zero = (torch.round(Wq * 1e6) == 0).float().mean().item()   # 0 이 된 가중치의 몫
        rows.append({"비트": bits, "스케일": how, "상대 오차": round(rel, 4), "0 이 된 몫": round(zero, 3)})
import pandas as pd
print(pd.DataFrame(rows).to_string(index=False))

text = open("shop_corpus.txt", encoding="utf-8").read()[:3000]       # 4차시의 가상 쇼핑몰 글
ids = tok(text, return_tensors="pt")["input_ids"][:, :512]           # 앞 512토큰


def perplexity(m):
    """labels 를 입력과 같게 주면 모델이 다음 토큰 예측의 평균 손실을 돌려준다. 그 exp 가 퍼플렉서티"""
    with torch.no_grad():
        loss = m(ids, labels=ids).loss
    return round(float(torch.exp(loss)), 3)


base_ppl = perplexity(model)
print("토큰:", ids.shape[1], "· 원래 모델(fp32) 퍼플렉서티:", base_ppl)

originals = {n: m.weight.detach().clone() for n, m in model.named_modules()
             if isinstance(m, torch.nn.Linear) and "lm_head" not in n}      # 출력층(lm_head)은 그대로 둔다
results = {"fp32(원래)": base_ppl}
for how, kw in [("int8 텐서마다", {"bits": 8}), ("int4 텐서마다", {"bits": 4}), ("int4 128개 묶음", {"bits": 4, "group": 128})]:
    for n, m in model.named_modules():
        if n in originals:
            m.weight.data = quantize(originals[n], **kw)          # 양자화했다 되돌린 값으로 바꿔 끼운다
    results[how] = perplexity(model)
for n, m in model.named_modules():                              # 원래 가중치로 되돌린다
    if n in originals:
        m.weight.data = originals[n]
print(results)
print("선형층", len(originals), "개를 바꿨다")