규모의 법칙 - 딥러닝 언어 모델

앞에서 우리는 Qwen3 0.6B 모델 하나를 밑바닥부터 만들어 공개 가중치를 이식했습니다. 그런데 왜 0.6B일까요? 왜 어떤 모델은 4B이고, 어떤 모델은 수백 B일까요? 모델을 무작정 키우면 더 똑똑해지기는 하는 걸까요, 아니면 어느 순간 한계에 부딪힐까요?

이 질문에 정량적인 답을 주는 것이 규모의 법칙(Scaling Laws)입니다. 모델의 크기, 데이터의 양, 투입한 연산량을 늘릴 때 성능이 얼마나, 어떤 모양으로 좋아지는지를 수식으로 예측하는 규칙입니다. 이 장에서는 규모의 법칙이 무엇인지 설명하고, 앞에서 만든 Qwen3 모델 코드를 그대로 재사용해 같은 계열의 크기가 다른 모델 세 개로 그 법칙을 눈으로 확인합니다.

1성능은 규모를 따라 거듭제곱으로 좋아진다¶

언어 모델의 사전 훈련 성능은 보통 검증 손실(validation loss), 즉 다음 토큰을 얼마나 잘 맞히는지로 측정합니다. 손실이 낮을수록 모델이 텍스트의 규칙을 잘 압축한 것입니다. 손실(교차 엔트로피)과 그 지수인 perplexity의 정의는 성능 평가 장에 있습니다.

규모의 법칙의 핵심 관찰은, 이 손실 $L$ 이 세 가지 자원에 대해 거듭제곱 법칙(power law)을 따른다는 것입니다.Kaplan et al. (2020)

L(N) \propto N^{-\alpha_N}, \qquad L(D) \propto D^{-\alpha_D}, \qquad L(C) \propto C^{-\alpha_C}

(1)

$N$ : 모델 파라미터 수
$D$ : 학습 데이터 크기 (토큰 수)
$C$ : 총 연산량 (FLOPs, 대략 $C \approx 6ND$ )

거듭제곱 법칙의 중요한 성질은 양변에 로그를 취하면 직선이 된다는 것입니다.

\log L = -\alpha_N \log N + (\text{상수})

(2)

즉 가로축에 $\log N$ , 세로축에 $\log L$ 을 찍으면 점들이 기울기가 $-\alpha_N$ 인 직선 위에 놓입니다. 이 직선이 깨지지 않고 여러 자릿수에 걸쳐 이어진다는 사실이야말로, "모델을 10배 키우면 손실이 예측 가능한 만큼 줄어든다"는 자신감의 근거이며, 거대 모델에 막대한 비용을 투자하는 공학적·경제적 이유입니다.

2직접 확인하기 — Qwen3 base 3종¶

법칙을 글로만 읽으면 와닿지 않습니다. 실제 모델로 직선을 그려 봅시다.

같은 팀이 같은 방식으로 학습시킨 Qwen3 base 계열에는 크기가 다른 모델들이 있습니다. 구조(RoPE·RMSNorm·SwiGLU·GQA)는 같고 폭·깊이만 키운 형제 모델이라, $N$ 만 달라졌을 때 손실이 어떻게 변하는지 보기에 알맞습니다.

모델	층수	은닉 차원	잠재 차원	어텐션 헤드	파라미터 수
Qwen3-0.6B-Base	28	1024	3072	16 (KV 8)	0.60B
Qwen3-1.7B-Base	28	2048	6144	16 (KV 8)	1.72B
Qwen3-4B-Base	36	2560	9728	32 (KV 8)	4.02B

모델 코드는 새로 쓰지 않습니다. Qwen3 장에서 만든 Qwen3 조립 함수와 이식 함수, 바이트 단위 BPE encode 를 거의 그대로 씁니다. 크기마다 달라지는 것은 단 두 가지입니다 — 공개된 config.json 에서 읽어 오는 하이퍼파라미터, 그리고 가중치 파일의 개수입니다.

import json, urllib.request, urllib.error
import numpy as np
import keras
from safetensors.numpy import load_file

기지 = lambda 모델명: f"https://huggingface.co/Qwen/{모델명}/resolve/main/"

def 설정_읽기(모델명):
    cfg = json.load(urllib.request.urlopen(기지(모델명) + "config.json"))
    return dict(어휘수=cfg["vocab_size"], 층수=cfg["num_hidden_layers"], 차원=cfg["hidden_size"],
                헤드수=cfg["num_attention_heads"], 키값헤드수=cfg["num_key_value_heads"],
                헤드차원=cfg["head_dim"], 잠재차원=cfg["intermediate_size"])

가중치는 모델이 커지면 여러 .safetensors 조각으로 나뉘어(sharded) 저장됩니다 — 0.6B·1.7B는 한 파일이지만 4B는 세 조각입니다. 인덱스 파일이 있으면 그 조각을 모두 합쳐 읽도록, 앞 장의 단일 파일 이식에서 이 부분만 일반화합니다. (이식 함수도 디코더 스택 이름을 decoder_x{층수} 로 받도록 한 줄만 고치면 어떤 크기든 그대로 동작합니다.)

def 가중치_읽기(모델명):
    url = 기지(모델명)
    try:                                                          # 샤드 모델은 인덱스 파일이 있음
        인덱스 = json.load(urllib.request.urlopen(url + "model.safetensors.index.json"))
        조각들 = sorted(set(인덱스["weight_map"].values()))
    except urllib.error.HTTPError:                                # 단일 파일(0.6B·1.7B)
        조각들 = ["model.safetensors"]
    가중치 = {}
    for 조각 in 조각들:                                            # 큰 파일은 받아서 캐시
        가중치.update(load_file(keras.utils.get_file(f"{모델명}-{조각}", url + 조각)))
    return 가중치

손실은 사전 훈련 그대로 인과적 언어 모델링(다음 토큰 예측)의 교차 엔트로피입니다. 로짓을 한 칸 밀어 다음 토큰과 맞추고, 토큰마다의 음의 로그 확률을 평균 냅니다.

def 손실(model, ids):
    로짓 = model.predict(np.array([ids], "int32"), verbose=0)[0].astype("float64")  # (T, 어휘수)
    예측, 정답 = 로짓[:-1], np.array(ids[1:])                          # 한 칸 밀기
    최대 = 예측.max(-1, keepdims=True)
    로그합 = 최대[:, 0] + np.log(np.exp(예측 - 최대).sum(-1))          # log-sum-exp
    선택 = 예측[np.arange(len(정답)), 정답]
    return float((로그합 - 선택).mean())                              # 평균 음의 로그 확률

평가 텍스트는 학습에 쓰지 않은 한국어 위키 문단(KorQuAD 검증 셋)으로, 세 모델 모두에 똑같이 줍니다. 크기마다 모델을 만들어 가중치를 이식하고, 손실과 파라미터 수 $N$ 을 기록합니다.

원본 = json.load(urllib.request.urlopen("https://korquad.github.io/dataset/KorQuAD_v1.0_dev.json"))
문단 = list(dict.fromkeys(p["context"] for g in 원본["data"] for p in g["paragraphs"]))
평가_텍스트 = "\n\n".join(문단[10:22])                            # 서로 다른 12개 문단

결과 = []
for 모델명 in ["Qwen3-0.6B-Base", "Qwen3-1.7B-Base", "Qwen3-4B-Base"]:
    설정 = 설정_읽기(모델명)
    model = Qwen3(**설정)
    model(np.zeros((1, 4), "int32"))                                 # 빌드
    이식(model, 가중치_읽기(모델명), 설정["층수"])
    손실값 = 손실(model, encode(평가_텍스트)[:900])
    결과.append((model.count_params(), 손실값))
    print(f"{모델명}: N={model.count_params()/1e9:.2f}B 손실={손실값:.4f} ppl={np.exp(손실값):.2f}")
    del model

Qwen3-0.6B-Base: N=0.60B 손실=2.7961 ppl=16.38
Qwen3-1.7B-Base: N=1.72B 손실=2.4488 ppl=11.57
Qwen3-4B-Base: N=4.02B 손실=2.2053 ppl=9.07

손실이 모델을 키울수록 매끄럽게 내려갑니다. 이 세 점을 로그-로그 평면에 놓고 직선을 맞추면, 그 기울기가 바로 거듭제곱 지수 $-\alpha_N$ 입니다.

N = np.log10([n for n, _ in 결과])
L = np.log10([l for _, l in 결과])
기울기, 절편 = np.polyfit(N, L, 1)
print(f"로그-로그 기울기(-alpha_N): {기울기:.3f}")

로그-로그 기울기(-alpha_N): -0.124

Qwen3 base 3종의 손실 대 파라미터 수(로그-로그). 세 점이 거의 한 직선에 놓여 거듭제곱 법칙을 보여준다.

세 점이 거의 한 직선 위에 놓입니다. 점이 셋뿐이고 평가 텍스트도 하나라 엄밀한 측정은 아니지만, 거듭제곱이라는 모양을 눈으로 확인하기에는 충분합니다. 원논문들은 모델 크기를 여러 자릿수에 걸쳐 바꿔 가며 이 직선이 길게 이어짐을 보였습니다.Kaplan et al. (2020)

3무엇을 키울 것인가 — Kaplan과 Chinchilla¶

연산 예산( $C$ )은 늘 한정되어 있습니다. 그렇다면 같은 예산을 모델 크기 $N$ 과 데이터 $D$ 에 어떻게 나눠야 손실이 가장 낮아질까요? 규모의 법칙의 역사는 이 배분 문제를 둘러싸고 전개되었습니다.

Kaplan 규모의 법칙Kaplan et al. (2020): 제한된 연산 예산에서는 데이터보다 모델 크기를 훨씬 빠르게 키우는 것이 효율적이라고 보았습니다. 이 결론은 "데이터는 적당히, 모델은 최대한 크게"라는 초창기 거대 모델 경쟁을 이끌었습니다.
Chinchilla 규모의 법칙Hoffmann et al. (2022): 학습률 일정 같은 조건을 바로잡아 다시 측정하니, 연산 예산을 늘릴 때 $N$ 과 $D$ 를 거의 1:1로 함께 키워야 최적이었습니다. 경험칙으로 파라미터 하나당 약 20개의 토큰이 균형점입니다.

Chinchilla의 교훈은 단순합니다. 당대의 많은 거대 모델이 사실은 데이터가 부족한 채로(under-trained) 학습되어 있었고, 같은 연산으로 더 작은 모델을 더 많은 데이터로 학습시키면 더 좋은 성능이 나왔습니다. 실제로 70B 규모 모델을 2조 개가 넘는 토큰으로 학습시키는 고밀도 사전 훈련 방식이 이때 자리 잡았습니다.

4한계, 그리고 다음 이야기¶

거듭제곱 법칙은 손실을 낮추지만 공짜가 아닙니다. 손실을 절반으로 줄이려면 $N$ 이나 $D$ 를 몇 배로 키워야 하므로, 수익은 갈수록 줄어듭니다(diminishing returns). 게다가 고품질 텍스트 데이터의 양은 유한하고, 연산 비용은 곧 전기와 칩의 한계에 부딪힙니다.

여기서 두 갈래의 길이 갈립니다. 하나는 모델을 더 키우되 연산은 아끼는 방향 — 토큰마다 일부 전문가만 켜는 혼합 전문가(MoE) 구조가 대표적입니다. 다른 하나는 사전 훈련만으로는 닿지 않는 능력(지시 따르기, 추론)을 사후 훈련으로 끌어내는 방향입니다.

규모의 법칙은 "왜 언어 모델이 점점 거대해졌는가"에 대한 답이자, 그 거대함이 어디서 멈추고 다른 기법으로 넘어가는지를 가늠하는 지도입니다. 대형 언어 모델 장에서는 이 지도를 들고, 규모가 만들어 내는 창발적 능력과 그것을 떠받치는 구조들을 살펴봅니다.

5정리¶

사전 훈련 손실은 모델 크기 $N$ ·데이터 $D$ ·연산량 $C$ 에 대해 거듭제곱 법칙을 따릅니다 — 로그-로그에서 직선입니다.
같은 코드로 만든 Qwen3 base 3종의 손실을 측정해, 점들이 한 직선에 놓이는 것을 직접 확인했습니다(모델 코드는 Qwen3 장 재사용).
Kaplan은 모델 크기를 빠르게 키우라 했고, Chinchilla는 $N$ 과 $D$ 를 함께(파라미터당 ~20토큰) 키우라고 바로잡았습니다.
거듭제곱의 수익은 체감하고 데이터·연산은 유한하므로, MoE 같은 효율 구조와 사후 훈련이 다음 과제가 됩니다.

References¶

Kaplan, J., McCandlish, S., Henighan, T., Brown, T. B., Chess, B., Child, R., Gray, S., Radford, A., Wu, J., & Amodei, D. (2020). Scaling Laws for Neural Language Models. https://arxiv.org/abs/2001.08361
Hoffmann, J., Borgeaud, S., Mensch, A., Buchatskaya, E., Cai, T., Rutherford, E., de Las Casas, D., Hendricks, L. A., Welbl, J., Clark, A., Hennigan, T., Noland, E., Millican, K., van den Driessche, G., Damoc, B., Guy, A., Osindero, S., Simonyan, K., Elsen, E., … Sifre, L. (2022). Training Compute-Optimal Large Language Models. https://arxiv.org/abs/2203.15556