Llama 3 Herd of Models 해부: LLM 한 개가 아니라 운영 가능한 모델군을 만드는 법

0단계 첫 논문. 이 글은 The Llama 3 Herd of Models 원문을 읽고 정리한 기록이다. 대상은 2024-11-23 공개된 arXiv v3이며, 논문은 모든 결과를 Llama 3.1 모델의 결과로 제시하면서 본문에서는 편의상 Llama 3이라고 부른다. 따라서 이 글은 2026년의 "가장 최신 Llama" 소개가 아니다.

이 글에서 얻을 답과 범위

이 글을 다 읽고 다음 질문에 답할 수 있으면 목표를 달성한 것이다.

1. Llama 3는 단순히 큰 Transformer 하나가 아니라, 어떤 데이터·학습·평가·안전·운영 공정의 결과인가?
2. 8B, 70B, 405B, 128K context는 각각 무엇을 뜻하며, 왜 숫자가 크다고 무조건 좋은 선택은 아닌가?
3. 사전학습(pre-training), 사후학습(post-training), **추론(inference)**은 무엇이 다르며 어디서 모델의 말투와 도구 사용 능력이 생기는가?
4. 긴 문맥, 그룹 질의 어텐션(Grouped-Query Attention, GQA), 키-값 캐시(Key-Value cache, KV cache)가 서비스 비용과 지연 시간에 어떤 영향을 주는가?
5. 백엔드·DBA 출신인 내가 이 논문에서 가져가야 할 실제 설계 원칙은 무엇인가?

범위도 고정한다. 이 글은 Llama 3.1 논문의 언어 모델 경로를 중심으로 한다. 논문 후반의 이미지·영상·음성 실험은 "언어 모델 본체를 바꾸지 않고 adapter(어댑터)를 붙이는 방향도 시험했다"는 경계까지만 다룬다. 그 멀티모달 모델은 논문 시점에 넓게 공개되지 않았고, 이 글의 첫 목표인 LLM 시스템 지도를 흐리기 때문이다.

그 경계가 무엇인지는 알아야 한다. 논문은 이미지·음성 encoder(인코더)를 별도로 사전학습한 뒤, cross-attention(교차 어텐션) adapter로 그 표현을 언어 모델에 넣는 실험을 했다. adapter 학습 때 언어 모델 가중치는 의도적으로 고정하고 이미지 encoder와 adapter를 조정했으며, 음성도 별도 경로를 사용했다. 즉 "Llama 3가 처음부터 모든 형태의 데이터를 같은 본체로 학습했다"는 뜻이 아니다. 원 논문 2절의 멀티모달 결과는 언어 모델 모델군과 별도의 연구 경로로 읽어야 한다.

먼저 외울 한 문장

Llama 3는 15조 개 규모의 토큰을 다음 토큰 예측으로 읽은 dense Transformer를, 사람의 선호·도구 사용·안전 규칙으로 여러 번 사후학습하고, 수만 장의 GPU 장애를 견디는 운영 시스템으로 만든 모델군이다.

여기서 15조 토큰은 문서 15조 개가 아니다. **토큰(token)**은 모델이 읽는 텍스트 조각이다. "안녕하세요"가 한 토큰일 수도, 여러 토큰일 수도 있다. 그리고 **dense Transformer(밀집 Transformer)**는 한 토큰을 처리할 때 선택된 일부 전문가만 실행하는 MoE(Mixture of Experts, 전문가 혼합)와 달리, 각 층의 일반적인 가중치를 모두 사용하는 구조를 말한다.

왜 필요한가: 좋은 챗봇은 모델 파일 하나로 생기지 않는다

처음에는 LLM(Large Language Model, 대규모 언어 모델)을 이렇게 오해했다.

많은 문서를 모은다 → GPU로 오래 돌린다 → 똑똑한 챗봇이 나온다

이 그림에는 중요한 실패가 빠져 있다.

• 웹 문서는 메뉴, 광고, 중복 문장, 개인정보(PII, Personally Identifiable Information)를 섞어 갖고 있다.
• 모델이 다음 단어를 잘 맞힌다고 해서 사용자의 지시를 따르거나, 모르면 멈추거나, 안전하게 도구를 호출하는 것은 아니다.
• 16,000장의 GPU 중 한 장만 멈춰도 동기식 학습 작업 전체가 멈출 수 있다.
• 벤치마크 점수가 높아도 학습 데이터에 시험 문제가 섞였을 수 있다.
• 입력과 출력에 필터를 붙이면 위험한 답변은 줄지만, 정상적인 질문도 거절하는 false refusal(잘못된 거절)이 늘 수 있다.

이 논문이 가치 있는 이유는 "405B라는 큰 숫자"보다 위 실패를 한 공정으로 보여 주기 때문이다. 저자들은 품질을 좌우하는 세 레버를 데이터, 규모, 복잡성 관리로 잡았다. 복잡한 MoE나 불안정하기 쉬운 온라인 강화학습을 첫 선택으로 밀어붙이기보다, 데이터 품질과 규모를 키우고 dense 구조·SFT·DPO라는 비교적 단순한 길을 택했다. 이 선택은 원 논문 1절의 명시적 설명이다.

백엔드 관점으로 바꾸면 다음과 같다.

"좋은 SQL 한 줄"만으로 좋은 데이터 서비스가 되지 않는다.
  → 원천 데이터 계약, 정제, 인덱스, 장애 복구, 모니터링, 권한, 회귀 테스트가 필요하다.

"좋은 모델 가중치"만으로 좋은 AI 서비스가 되지 않는다.
  → 데이터 정제, 학습, 사후학습, 평가, 가드레일, 추론 자원, 운영 절차가 필요하다.

이 비유가 이 논문을 읽는 핵심이다. 모델은 서비스의 한 컴포넌트이지 서비스 전체가 아니다.

무엇인가: Llama 3, Llama 3.1, Base, Instruct를 분리하기

논문 제목의 **herd(무리)**는 모델 하나가 아니라 크기와 학습 상태가 다른 모델군이라는 뜻이다. 표 1 기준 모델군은 다음과 같다.

논문은 8B·70B·405B Llama 3.1 언어 모델을 다루며, 405B는 128K 토큰 문맥 창을 지원한다고 보고한다. 공식 Llama 3.1 모델 카드도 세 크기, 128K 문맥, 15T+ 사전학습 토큰, 2023년 12월 지식 절단일을 명시한다.

여기서 세 가지를 분리해야 한다.

1. 파라미터는 문서를 그대로 저장한 DB 행이 아니다. 학습으로 조정된 숫자이며, 특정 문장을 원문 그대로 꺼내는 저장소가 아니다.
2. 128K는 입력 상한이다. 128K 문서를 주면 그 모든 근거를 항상 정확하게 찾는다는 품질 보증이 아니다.
3. Instruct는 RAG(Retrieval-Augmented Generation, 검색 증강 생성)가 아니다. Instruct는 모델의 행동을 맞춘 것이고, RAG는 요청 시 외부 최신 문서를 검색해 문맥에 넣는 시스템 설계다.

선행 개념: 12살에게 먼저 설명해야 하는 단어들

토큰, 임베딩, 확률

컴퓨터는 문장을 바로 다루지 못한다. tokenizer(토크나이저)가 텍스트를 숫자 ID의 열로 쪼갠다.

"펌프 압력이 낮다"
→ [토큰 101, 토큰 827, 토큰 19, ...]
→ 각 ID를 숫자 벡터(vector, 숫자 목록)로 바꾼다.

각 벡터는 **embedding(임베딩)**이다. 모델은 현재까지의 토큰 벡터를 보고 다음 토큰마다 확률을 낸다.

P("압력" | "펌프") = 0.42
P("온도" | "펌프") = 0.18
P("바나나" | "펌프") = 0.00001

가장 높은 확률만 고르면 항상 같은 답이 나온다. temperature(온도)나 top-p 같은 sampling(샘플링) 규칙을 적용하면 후보 중 하나를 확률적으로 고른다. 이것이 "모델이 다음 단어를 생성한다"의 실제 의미다.

Llama 3 표 3은 어휘 크기(vocabulary size)를 128,000으로 보고한다. tiktoken 계열 100K 토큰에 비영어권 지원용 28K 토큰을 더한 구성이다. 논문은 영어 표본에서 Llama 2 대비 문자/토큰 압축률이 3.17에서 3.94로 높아졌다고 보고한다. 이것은 그 표본의 압축률이지 모든 언어·업무 문서에서 같은 비율을 보장하는 수치가 아니다.

Transformer와 decoder-only

Transformer는 토큰들이 서로의 정보를 참고해 표현을 고치는 신경망 구조다. Llama 3는 미래 토큰을 보지 못하게 가리는 causal mask(인과 마스크)를 쓰는 **decoder-only Transformer(디코더 전용 Transformer)**다.

문장 A B C를 학습할 때의 목표는 다음이다.

입력: <시작> A B
정답:       A B C

수식으로는 전체 토큰열 x_1, x_2, ..., x_T의 확률을 앞 토큰 조건부 확률의 곱으로 표현한다.

Pθ(x_1, ..., x_T) = Π Pθ(x_t | x_1, ..., x_(t-1))

• θ(theta)는 학습되는 모든 가중치다.
• T는 토큰 수다.
• Π는 모든 시점의 확률을 곱한다는 뜻이다.

학습은 정답 토큰의 확률이 커지도록 가중치를 고친다. 실제로는 곱을 그대로 다루기 어려워서 negative log-likelihood(음의 로그 가능도) 또는 cross-entropy(교차 엔트로피) 손실을 최소화한다.

L = -Σ log Pθ(정답 토큰 | 앞 문맥)

정답 확률이 1에 가까우면 -log 값은 작고, 정답 확률이 작으면 손실은 커진다. 이 한 줄이 사전학습의 중심이다.

사전학습과 사후학습

"사후학습이 사전학습보다 작으니 덜 중요하다"는 오해가 있다. 사용자는 대개 Instruct 모델의 행동을 본다. 같은 지식 기반이라도 사후학습 데이터와 평가가 다르면 답변 형식, 거절, 도구 호출, 사실성의 체감이 크게 달라진다.

밑바닥 원리: 데이터·규모·목표 함수를 차례로 쌓는 법

1. 웹을 그대로 먹이지 않는다: 데이터 파이프라인

Llama 3의 사전학습 데이터는 2023년 말까지의 여러 공개 원천에서 왔다. 아래 공정은 원 논문 3.1절이 공개한 범위다.

원천 웹/코드/수학/다국어 데이터
  → PII·성인물·위험 도메인 제거
  → HTML에서 본문 추출, 수식·코드 구조 보존
  → URL 중복 제거
  → 문서 유사 중복(MinHash) 제거
  → 반복 줄 제거
  → 반복 n-gram·더러운 단어·이상 토큰 분포 필터
  → 품질 분류기와 도메인별 코드/수학 분류기
  → 토큰화·데이터 비율 결정

여기서 **중복 제거(deduplication)**는 비용 절감 이상의 의미가 있다. 같은 문장이 수천 번 반복되면 모델은 그 문장을 과도하게 외우고, 평가셋과 비슷한 문장이 학습에 섞일 위험도 커진다. 논문은 URL 수준에서 최신 버전을 남기고, 문서 수준에서는 **MinHash(문서의 일부 조각으로 유사도를 싸게 추정하는 fingerprint 기법)**로 근사 중복을 제거하며, 줄 수준에서는 3천만 문서 묶음에서 6회보다 많이 나온 줄을 제거했다고 쓴다. 반복 줄 제거가 좋은 문장도 지울 수 있지만, 실험에서는 성능 개선이 더 컸다고 보고한다. 따라서 이것은 보편 법칙이 아니라 해당 실험의 트레이드오프다.

최종 데이터 비율은 약 50% 일반 지식, 25% 수학·추론, 17% 코드, 8% 다국어다. 이 비율도 "웹의 자연 분포"가 아니라 작은 모델과 scaling law(스케일링 법칙) 실험으로 고른 설계값이다. 웹에서 너무 많은 분야는 downsample(다운샘플)하고, 필요한 분야는 올린다.

2. 계산 예산을 먼저 정하고 모델 크기를 고른다: scaling law

FLOPs(Floating-point Operations, 부동소수점 연산 횟수)는 대략 "얼마나 많은 수치 계산을 할 수 있는가"를 나타내는 예산 단위다. 원 논문 3.2.1절은 405B 학습 예산을 3.8 × 10^25 FLOPs로 두고, 작은 실험의 손실과 성능을 이용해 큰 모델의 적절한 크기와 토큰 수를 예측했다.

논문의 단순화한 관계식은 다음이다.

N*(C) = A × C^α

• C: 사전학습 계산 예산(FLOPs)
• N*(C): 그 예산에서 손실이 가장 낮을 것으로 예측한 학습 토큰 수
• A, α: 작은 실험 결과에 맞춘 상수

논문은 α = 0.53, A = 0.29로 맞춘 뒤 405B급에서는 약 402B 파라미터와 16.55T 토큰을 예측했고, 실제 405B와 15.6T 토큰을 택했다. 중요한 교훈은 "파라미터를 최대한 크게"가 아니다. 고정된 돈·전력·시간 안에서 모델 크기와 데이터 양을 함께 고른다는 것이다.

3. 긴 문맥은 공짜가 아니다

일반 self-attention(셀프 어텐션)은 길이 T인 문장에서 토큰 쌍 점수를 대략 T × T개 만든다. 그래서 문맥 길이를 8K에서 128K로 16배 늘리면, 단순한 점수 행렬의 칸 수는 256배가 된다.

8,192²   =     67,108,864개 점수 칸
131,072² = 17,179,869,184개 점수 칸

실제 고성능 구현은 전체 점수 행렬을 항상 한 번에 저장하지 않도록 최적화한다. 그래도 "문맥을 16배로 늘렸으니 비용도 16배"라고 생각하면 틀린다. 원 논문 3.4.2절은 처음부터 긴 문맥으로 학습하지 않고, 8K에서 시작해 여섯 단계로 128K까지 올렸으며, 이 long-context pre-training(장문 문맥 사전학습)에 약 800B 토큰을 썼다고 설명한다. 각 단계에서 짧은 문맥 성능이 회복됐는지와 needle in a haystack(긴 문서 속 바늘 찾기) 과제를 통과했는지를 확인했다.

여기서도 경계를 지켜야 한다. 바늘 찾기 통과는 유용한 진단이지, 실제 복잡한 계약서·코드베이스·RAG 문서에서의 정답성을 증명하지 않는다.

내부 구조와 실제 실행 흐름

모델 본체: 작은 변경을 분명히 하자

논문 표 3의 핵심 구조는 다음과 같다.

Llama 3는 Llama 2와 크게 다른 새 블록을 발명했다기보다, 데이터 품질·데이터 다양성·학습 규모를 크게 키운 dense Transformer다. 논문이 강조한 구조 변경은 특히 세 가지다.

1. GQA: 8개의 KV head를 여러 Query head가 나눠 써서 decoding(디코딩) 때 KV cache를 줄인다.
2. 문서 경계 attention mask: 한 시퀀스에 여러 문서를 묶어 넣어도 서로 다른 문서끼리 self-attention하지 못하게 막는다.
3. 128K tokenizer와 RoPE 설정: 128K 어휘와 RoPE(Rotary Position Embedding, 회전 위치 임베딩) base θ = 500,000를 사용하고, 별도 장문 문맥 학습으로 128K까지 확장한다. RoPE는 Query와 Key 벡터의 두 숫자씩을 위치에 따라 회전해, attention이 토큰 사이의 상대 위치를 읽게 하는 방법이다.

**SwiGLU(Swish-Gated Linear Unit)**도 표에 보이지만 겁낼 필요는 없다. FFN(Feed-Forward Network, 토큰 하나 안에서 값을 비선형 변환하는 층)에서 한 경로의 값을 Swish라는 부드러운 활성화 함수에 통과시키고, 다른 경로 값과 곱해 "이 정보가 지금 통과할지"를 조절하는 gate(게이트)다. 이 글에서는 수식을 외우는 것보다 attention이 토큰 사이 정보를 섞고, SwiGLU FFN이 각 토큰 안의 표현을 변환한다는 역할 분리가 중요하다.

GQA와 KV cache: 왜 서비스 비용의 단어인가

모델이 첫 입력을 읽는 prefill(프리필) 뒤에는 답을 한 토큰씩 생성한다. 매 새 토큰마다 과거 모든 토큰의 Key·Value를 다시 계산하면 너무 느리다. 그래서 각 층의 과거 Key·Value를 GPU 메모리에 저장하는 것이 KV cache다.

Multi-Head Attention(MHA)은 Query head마다 Key·Value head를 둔다. GQA는 여러 Query head가 하나의 Key·Value head를 공유한다.

MHA: Q0→KV0, Q1→KV1, Q2→KV2, Q3→KV3
GQA: Q0→KV0, Q1→KV0, Q2→KV1, Q3→KV1

논문의 8B 설정은 Query head 32개, KV head 8개다. head당 차원은 4096 / 32 = 128이다. 배치 1개, BF16 또는 FP16의 값 하나를 2 byte라고 단순화하면 KV cache의 이론상 크기는 다음처럼 계산된다.

cache bytes
= 2(K와 V) × 층 수 × KV head 수 × head 차원 × 토큰 수 × 값 하나의 byte 수

공식 초기 Llama 3 예제 소스의 Attention 구현도 KV head 수가 Query head 수보다 적으면 repeat_kv로 논리적으로 반복하고, cache_k·cache_v에 현재 Key·Value를 저장한다. 모델 코드의 head 계산·cache 할당을 보면 이 흐름을 직접 확인할 수 있다.

다만 이 저장소는 Llama 3.1 배포 뒤 deprecated(더 이상 권장되지 않음)라고 표시한 초기 예제다. 아래 코드는 논문의 8B 표 3 숫자로 GQA 원리를 검증한 것이며, 405B 가중치를 실행한 결과가 아니다.

사전학습 실제 흐름

정제된 문서
  → tokenizer가 토큰 ID열 생성
  → 여러 문서를 packing(묶기)하되 문서 경계 마스크 적용
  → decoder-only Transformer가 다음 토큰 확률 계산
  → 정답 토큰과의 cross-entropy 손실 계산
  → AdamW optimizer가 가중치 갱신
  → checkpoint 저장·장애 시 재개
  → 8K → 128K continued pre-training
  → 마지막 learning-rate annealing과 checkpoint 평균

405B 초기 사전학습은 AdamW, 8,000 step 선형 warmup, 이후 cosine learning-rate decay를 사용했다고 보고한다. AdamW는 이전 gradient(오차를 줄이는 방향)의 평균을 이용해 가중치 수정 크기를 조절하고, weight decay(가중치가 너무 커지는 것을 누르는 규칙)를 분리해 적용하는 optimizer(가중치 갱신기)다. warmup은 시작부터 큰 학습률을 쓰지 않고 천천히 올리는 안정화 구간이고, cosine decay는 학습 후반에 수정 폭을 곡선으로 줄이는 일정이다. 마지막 40M 토큰에서는 학습률을 0으로 선형 감소시키고 고품질 데이터 비율을 올리며 checkpoint 평균을 내 최종 사전학습 모델을 만들었다.

사후학습 실제 흐름: 좋은 답을 골라 행동을 맞춘다

사전학습 모델은 글을 이어 쓰는 법을 배웠지만, "사용자 질문에 바로 답하고, 필요한 때만 도구를 정확한 형식으로 호출하라"는 계약을 아직 모른다. 원 논문 4.1~4.2절은 Llama 3가 다음 순환을 여섯 번 수행했다고 설명한다.

사전학습 checkpoint
  → 사람의 선호 쌍(chosen / rejected)으로 Reward Model(RM) 학습
  → 한 prompt에 K개(보통 10~30개) 답 생성
  → RM이 가장 좋은 답 선택: rejection sampling(RS)
  → 사람 데이터 + 합성 데이터 + RS 답으로 SFT
  → chosen 답을 rejected 답보다 선호하도록 DPO
  → 새 모델로 더 어려운 사람 평가·합성 데이터 수집
  └────────────────────────────────────── 반복

• Reward Model(RM, 보상 모델): 질문 + 답변을 보고 사람이 더 좋아할 답에 높은 점수를 주도록 학습한 채점기다.
• Rejection sampling(RS, 거절 샘플링): 여러 후보를 만든 뒤 나쁜 후보를 버리고 RM이 고른 후보를 남긴다. 이름의 rejection은 "사용자 요청을 거절한다"는 뜻이 아니다.
• Supervised Fine-Tuning(SFT, 지도 미세조정): 좋은 대화 예시의 assistant 답 토큰을 정답으로 두고 학습한다. 논문은 prompt 토큰에는 손실을 주지 않고 target 답 토큰에 cross-entropy를 적용했다고 쓴다.
• Direct Preference Optimization(DPO, 직접 선호 최적화): chosen 답의 상대 확률은 올리고 rejected 답의 상대 확률은 내리는 방식으로 선호를 반영한다. 논문은 PPO 같은 on-policy 강화학습보다 큰 모델에서 계산량이 적고 지시 이행 평가가 좋았다고 보고했다.

일반적인 DPO의 모양은 아래와 같다. 처음 보는 수식이라도 좋은 답 - 나쁜 답의 차이를 크게 만들려는 식이라는 뼈대를 잡으면 된다.

L_DPO = -log σ( β × [
  log πθ(y좋음 | x) - log πref(y좋음 | x)
  - log πθ(y나쁨 | x) + log πref(y나쁨 | x)
])

• x: prompt(질문과 앞 대화)
• y좋음, y나쁨: 사람이 비교한 선호·비선호 답
• πθ: 지금 업데이트할 모델의 답변 확률
• πref: 기준 모델의 답변 확률
• σ: 값을 0~1로 누르는 sigmoid(시그모이드) 함수
• β: 선호 차이를 얼마나 강하게 반영할지 정하는 값

논문은 Llama 3 DPO에서 β = 0.1을 쓰고, 선택된 답의 negative log-likelihood 손실을 0.2 비율로 더했으며, header·turn 종료 같은 서식 토큰은 DPO 손실에서 마스킹했다고 구체적으로 밝힌다. 공통 서식 토큰까지 chosen과 rejected에서 서로 반대 방향으로 밀면 반복·조기 종료가 생길 수 있었기 때문이다.

채팅 형식도 모델 계약이다

"프롬프트는 그냥 문자열"이라는 생각도 불완전하다. Instruct 모델은 역할과 턴 경계를 특정 special token(특수 토큰)으로 학습했다. 초기 공식 예제의 ChatFormat은 다음 순서를 만든다.

<|begin_of_text|>
<|start_header_id|>system<|end_header_id|>

시스템 지시문<|eot_id|>
<|start_header_id|>user<|end_header_id|>

사용자 질문<|eot_id|>
<|start_header_id|>assistant<|end_header_id|>

마지막 assistant header 뒤를 모델이 이어 쓰게 한다. 공식 tokenizer의 encode_header, encode_message, encode_dialog_prompt와 생성 진입점을 읽으면, 포맷이 틀리면 모델이 학습 때 보지 못한 입력을 받는 이유가 보인다.

대규모 학습도 분산 시스템이다

405B 학습은 최대 16K H100 GPU(각 80GB HBM3, HBM은 GPU 옆의 고대역폭 메모리)를 사용했다. 원 논문 3.3절에 따르면 한 GPU에 모델·optimizer 상태·문맥·배치를 모두 넣을 수 없으므로 4D parallelism(4차원 병렬화)을 썼다.

논문 표 4에서 128K 단계는 TP=8, CP=16, PP=16, DP=8을 썼다. 긴 문맥에서 CP가 필요한 이유가 여기 있다. 8K 단계에서는 CP가 1이었지만 128K 단계에서는 문맥 자체를 나눠야 메모리 병목을 버틸 수 있었다.

이것은 연구실의 이상적인 그림이 아니다. 원 논문 3.3.4절은 54일 관찰 기간에 466번의 학습 중단이 있었고, 계획된 중단 47번을 제외한 419번의 비계획 중단 중 약 78%가 확인되거나 의심되는 하드웨어 문제였다고 보고한다. 저자들은 checkpoint, 자동 진단, NCCL(NVIDIA Collective Communications Library, GPU 사이 집단 통신 라이브러리) 통신 trace, 느린 straggler(유난히 느린 작업자) 탐지로 90% 넘는 유효 학습 시간을 유지했다고 보고한다. 모델 학습도 결국 관측 가능성, 체크포인트, 재시도, 장애 격리가 필요한 분산 운영이다.

직접 검증: 논문 수치를 작은 프로그램으로 확인하기

검증 범위와 환경

직접 실행 확인: 2026-07-24, macOS 26.4.1, Python 3.9.6. 이 컴퓨터에는 NVIDIA GPU와 Llama 3 가중치가 없었다. 따라서 "405B를 실행했다"고 주장하지 않는다.

대신 원 논문 표 3의 8B 숫자로 다음 세 가지를 직접 계산했다.

1. 문서 경계 마스크가 다른 문서로 가는 attention 확률을 0으로 만드는가
2. GQA가 MHA보다 KV cache를 4배 줄이는가
3. 8K에서 128K로 길이를 늘리면 T² 점수 칸이 256배가 되는가

아래 코드는 외부 라이브러리 없이 실행했다.

# /tmp/verify_llama3_core_mechanics.py
from math import exp

def softmax(values):
    finite = [v for v in values if v != float("-inf")]
    ceiling = max(finite)
    exp_values = [0.0 if v == float("-inf") else exp(v - ceiling) for v in values]
    total = sum(exp_values)
    return [value / total for value in exp_values]

# 문서 A 세 토큰 + 문서 B 세 토큰을 한 sequence에 packing했다고 가정한다.
document_id = ["A", "A", "A", "B", "B", "B"]
query_position = 4  # 문서 B의 두 번째 토큰
raw_scores = [0.2, 0.5, 0.1, 1.0, 2.0, 0.3]
masked_scores = [
    score if document_id[key_position] == document_id[query_position] else float("-inf")
    for key_position, score in enumerate(raw_scores)
]
weights = softmax(masked_scores)
print("cross-document weight:", sum(weights[:3]))
print("same-document weight:", round(sum(weights[3:]), 4))

def kv_cache_mib(layers, kv_heads, head_dimension, sequence_length, bytes_per_value=2):
    # 2는 K와 V 두 cache, 2 byte는 BF16/FP16 scalar 하나를 뜻한다.
    return 2 * layers * kv_heads * head_dimension * sequence_length * bytes_per_value / (1024 ** 2)

layers, query_heads, kv_heads = 32, 32, 8
head_dimension = 4096 // 32
for sequence_length in (8_192, 131_072):
    mha = kv_cache_mib(layers, query_heads, head_dimension, sequence_length)
    gqa = kv_cache_mib(layers, kv_heads, head_dimension, sequence_length)
    print(f"{sequence_length:,}: MHA={mha:,.0f} MiB, GQA={gqa:,.0f} MiB, ratio={mha / gqa:.0f}x")
    print(f"attention score cells: {sequence_length ** 2:,}")

실행 결과는 다음과 같았다.

cross-document weight: 0.0
same-document weight: 1.0
8,192: MHA=4,096 MiB, GQA=1,024 MiB, ratio=4x
attention score cells: 67,108,864
131,072: MHA=65,536 MiB, GQA=16,384 MiB, ratio=4x
attention score cells: 17,179,869,184

해석은 조심해야 한다.

• 1,024MiB는 8B 모델 한 요청, batch 1, 모든 층, 8K 토큰, KV만의 이론 계산이다. 가중치, 활성화 값, allocator 여유 공간, 배치 수, 서버 프레임워크 메타데이터는 빠져 있다.
• GQA가 4배 작아진 이유는 32 / 8 = 4다. 품질이 "공짜로" 4배 좋아진다는 뜻은 아니다.
• 실제 attention 구현은 FlashAttention 같은 방법으로 전체 T×T 행렬을 한 번에 저장하지 않을 수 있다. 이 계산은 긴 문맥이 근본적으로 더 비싸다는 크기 관계를 보이는 용도다.
• 문서 마스크 검증은 논문이 말한 마스크의 단순화한 수학 예제다. Meta의 실제 학습 클러스터 재현이 아니다.

성능과 트레이드오프: 큰 모델·긴 문맥·안전은 각각 대가가 있다

Dense Transformer 대 MoE

논문의 결론은 "MoE는 나쁘다"가 아니다. 당시 목표와 인프라에서 안정적인 대규모 학습을 우선해 dense를 골랐다는 것이다. 기술 선택을 논문 제목이나 유행이 아니라 내 데이터·예산·운영 능력으로 해야 한다는 사례다.

긴 문맥 대 RAG

그래서 내 장기 목표가 데이터 파이프라인과 retrieval infrastructure(검색 인프라)인 이유가 더 선명해진다. 128K 모델을 고르는 것만으로 최신성, 출처, 권한, 재현성 문제가 사라지지 않는다.

사후학습 대 데이터 품질

Llama 3는 합성 데이터를 적극 사용했다. 공식 모델 카드는 2,500만 개가 넘는 합성 fine-tuning 예시를 언급한다. 하지만 합성 데이터는 강한 모델의 실수·말투·편향도 증폭할 수 있다. 그래서 논문은 rule 기반 정제, RM과 Llama 기반 품질 점수, 난이도 점수, 의미 중복 제거, 사람의 품질 검토를 같이 썼다.

이것은 RAG 평가에도 그대로 연결된다. LLM judge 하나의 점수만 믿지 말고, golden set(정답이 봉인된 평가셋), retrieval recall, 인용 근거, abstention, 실패 유형을 분리해 봐야 한다.

실패, 한계, 장애와 운영 기준

논문이 스스로 밝힌 한계

1. 안전성 테스트는 모든 위험을 포괄할 수 없다. 특히 영어 이외 언어와 숙련된 공격자의 jailbreak(안전 규칙 우회)는 남는다.
2. contamination(오염) 탐지는 열린 문제다. n-gram 중복은 거짓 양성·거짓 음성을 모두 낼 수 있다.
3. 일부 안전성 결과는 내부 benchmark라서 외부가 완전히 재현할 수 없다.
4. 모델 카드가 지원 언어로 명시한 범위 밖 언어는 성능·안전성을 별도로 검증해야 한다.
5. 긴 문맥 테스트 통과가 모든 장문 업무 성능을 보장하지 않는다.

안전은 모델 안과 밖을 모두 봐야 한다

논문은 5.4.7절에서 모델 사후학습만으로 끝내지 않고 Llama Guard 3 같은 **system-level safety(시스템 수준 안전장치)**를 소개한다. 입력 prompt와 출력 response를 별도 분류기로 검사하는 방식이다. 도구 사용에는 prompt injection(프롬프트 주입)도 위험하다. 검색해 넣은 외부 문서가 "이전 지시를 무시하라"고 써도, 그것을 사용자 명령처럼 실행하면 안 된다.

하지만 guard를 추가하면 false refusal이 증가할 수 있다. 즉 안전 설계의 목표는 "차단율 최대화"가 아니라, 업무 위험에 맞춰 위반률·잘못된 거절률·사용자 과업 성공률의 균형을 측정하는 것이다.

내가 운영한다면 남길 관측값

Llama 3의 16K GPU 사례를 내 RAG/AI 백엔드 규모로 번역하면 다음을 남긴다.

요청: model / prompt version / index release / tenant / trace ID
검색: candidate 수 / filter 탈락 수 / rerank 시간 / citation ID
생성: input·output token 수 / TTFT / TPOT / stop reason / provider error
안전: prompt injection 탐지 / ACL 차단 / false refusal 표본
데이터: source revision / chunk version / embedding model / manifest / rollback ID
평가: dev·locked 분리 / slice별 recall / 근거 없는 주장 / 회귀 여부

• TTFT(Time To First Token): 첫 토큰이 사용자에게 보이기까지 시간이다. prefill 병목을 드러낸다.
• TPOT(Time Per Output Token): 출력 토큰 하나를 더 만드는 평균 시간이다. decode와 KV cache 병목을 드러낸다.
• manifest(매니페스트): "어떤 코드·모델·프롬프트·데이터·인덱스로 이 응답을 만들었는가"를 묶은 배포 기록이다.

이 기록이 없으면 "새 모델이 좋아졌다"와 "인덱스가 바뀌었다"와 "사용자 질문이 쉬웠다"를 분리할 수 없다.

평가: 점수를 읽기 전에 실험 계약을 읽는다

논문 표 2의 점수는 성능의 한 단면일 뿐이다. 원 논문 5.1절은 사전학습 모델을 상식·세계지식·독해·수학·코드·장문 문맥·적대적 평가 등 여덟 범주로 나눠 측정했고, benchmark 값의 분산을 95% confidence interval(95% 신뢰구간)으로 보고하려 했다. 사후학습 모델은 별도 benchmark와 사람의 pairwise evaluation(두 답 중 어느 쪽이 나은지 고르는 비교 평가)을 사용했다.

좋은 점수표를 읽을 때는 아래를 먼저 확인한다.

무슨 모델인가?        Base인가 Instruct인가?
무슨 입력인가?        0-shot인가, few-shot인가, CoT를 허용했는가?
무슨 지표인가?        정확도인가, pass@k인가, 사람 선호인가?
무슨 데이터인가?      학습 데이터와 겹칠 가능성은 점검했는가?
무슨 비교인가?        같은 prompt·같은 도구·같은 비용·같은 버전인가?

**contamination(평가 오염)**은 시험 문제가 교재에 들어간 것과 비슷하다. 논문은 사전학습 코퍼스와 평가셋의 8-gram 중복으로 오염 가능성을 추정하고, 사후학습 데이터에서는 benchmark prompt와 exact match를 제거했다고 설명한다. 하지만 저자들도 최선의 오염 탐지가 아직 열린 연구 문제라고 명시한다. 그래서 표 2의 특정 수치를 오늘의 다른 모델이나 내 서비스 품질과 직접 등치하면 안 된다.

대안, 비교와 선택 기준

Base, Instruct, RAG를 고르는 기준

이 논문을 읽고 당장 하지 않을 일

• 405B 사전학습을 재현하려 하지 않는다. 수만 GPU·15T 토큰·분산 운영의 문제가 필요한 과제다.
• 모델 표의 벤치마크 점수만 보고 "최고 모델"을 선언하지 않는다. 논문 버전·prompt·shot·CoT·오염 가능성이 다르다.
• 128K라서 RAG가 필요 없다고 결론 내리지 않는다.
• Llama Guard를 붙였으니 안전하다고 선언하지 않는다. 업무별 attack corpus와 negative test가 필요하다.
• 논문이 DPO를 선택했으니 내 문제에도 DPO가 최적이라고 가정하지 않는다. 먼저 prompt·retrieval·데이터 품질·SFT로 어떤 실패를 해결하지 못했는지 측정한다.

흔한 오해와 최초 질문에 대한 답

오해 1: "Llama 3의 핵심은 405B 파라미터다"

아니다. 논문이 반복해 보여 주는 핵심은 고품질 데이터, 스케일링 판단, 복잡성 관리, 반복 사후학습, 운영 신뢰성의 결합이다. 405B는 그 공정이 만든 한 결과다.

오해 2: "사전학습 모델이 똑똑하면 자동으로 좋은 비서다"

아니다. 다음 토큰 예측 모델이 대화 역할, 도구 호출 형식, 선호, 안전을 자동으로 아는 것은 아니다. RM → RS → SFT → DPO와 평가 데이터가 행동을 바꾼다.

오해 3: "128K context면 모든 문서를 넣으면 된다"

아니다. 길이는 입력 상한이고, attention 비용·KV cache·잡음·권한·인용·최신성 문제는 별개다. 긴 문맥과 RAG는 경쟁 관계가 아니라, 실패 유형에 따라 함께 설계할 수 있는 도구다.

오해 4: "공식 코드가 8K라고 하니 논문의 128K 주장과 모순이다"

아니다. 초기 meta-llama/llama3 예제는 8K 모델을 위한 코드였고, 저장소 README는 Llama 3.1 이후 통합 저장소로 옮겼다고 밝힌다. 이 글에서 그 코드는 GQA·RoPE·KV cache·채팅 포맷의 실행 경로를 읽는 보조 근거로만 썼다. 128K 모델군의 사실 근거는 논문 표 1·3·3.4.2와 Llama 3.1 모델 카드다.

오해 5: "이 논문을 다 이해했으니 이제 LLM을 만들 수 있다"

아니다. 이 글은 LLM 시스템의 지도를 얻는 첫 단계다. 다음 글에서는 DeepSeek-V3로 dense와 MoE의 선택을 비교하고, 그 다음에는 Attention·tokenizer·GQA·RAG 평가 논문을 각각 독립적으로 내려가야 한다.

전문가에게 1분 안에 설명한다면

Llama 3 Herd는 Llama 3.1 8B·70B·405B dense decoder Transformer를 다룬 시스템 논문입니다. 핵심 기여는 새 attention 블록 하나가 아니라, 약 15T 토큰의 정제·혼합 데이터, 3.8×10²⁵ FLOPs 규모의 scaling-law 기반 설계, 8K에서 128K로 가는 continued pre-training, RM·rejection sampling·SFT·DPO의 반복 사후학습, 16K H100 분산 학습 운영, 그리고 모델 밖 safety guard와 오염 분석을 한 공정으로 공개한 점입니다. 제품 관점에서는 긴 문맥과 모델 크기만 고르지 말고 데이터·평가·KV cache 비용·권한·관측성을 함께 설계하라는 논문으로 읽었습니다.

출처

1차 자료

1. Llama Team, The Llama 3 Herd of Models, arXiv:2407.21783v3, 2024-11-23. 이 글의 모델군, 데이터, 표 3 구조, scaling law, 4D 병렬화, 사후학습, 평가, 안전성의 주 근거다.
2. Meta Llama, Llama 3.1 Model Card. 모델 크기, 문맥 길이, 지원 언어, 학습 토큰, 모델 카드의 적용 범위를 확인했다.
3. Meta Llama, llama3 모델 예제 코드, commit a0940f9. KV cache·GQA·RoPE 실행 경로, 채팅 포맷, 생성 loop를 읽었다. 이 저장소는 README에서 deprecated라고 밝히므로 Llama 3.1 128K 구현 전체의 증거로 사용하지 않았다.

직접 실행한 검증

• 2026-07-24, macOS 26.4.1, Python 3.9.6에서 본문의 순수 Python 계산을 실행했다.
• 실행 범위: 문서 경계 마스크, 표 3의 8B GQA KV cache 산술, T² 길이 증가 산술.
• 미실행 범위: Llama 3/3.1 가중치 추론, 16K GPU 분산 학습, 논문 benchmark 재현. 이 결과를 실행한 것처럼 쓰지 않았다.

다음 글

• 0단계 2편: DeepSeek-V3 Technical Report — dense 모델을 선택한 Llama 3와, MoE·MLA를 선택한 DeepSeek-V3를 같은 질문으로 비교한다.