LLM은 어떻게 배우고, 어떻게 대답하는가?

― Training과 Inference를 하나의 흐름으로 이해하기

LLM을 처음 공부하면 Tokenizer, Embedding, Attention, Transformer, Loss, Gradient, Logits, Softmax, KV Cache 같은 수많은 용어가 등장한다.

처음에는 각각 별개의 기술처럼 보인다.

하지만 이 개념들은 하나의 처리 흐름 안에서 서로 연결되어 있다.

가장 먼저 다음 두 문장을 기억하면 된다.

Training은 모델의 파라미터를 데이터에 맞게 조정하는 과정이고, Inference는 조정이 끝난 파라미터를 사용해 출력을 계산하는 과정이다.

자동차에 비유하면 다음과 같다.

text

┌──────────────────────────────────────┐
│ Training                             │
│ 자동차를 설계하고 만들고 튜닝하는 과정 │
└──────────────────┬───────────────────┘
                   ↓
             완성된 자동차
                   ↓
┌──────────────────────────────────────┐
│ Inference                            │
│ 완성된 자동차를 실제 도로에서 운전하는 과정 │
└──────────────────────────────────────┘

LLM도 비슷하다.

학습 과정에서는 모델 내부의 수많은 숫자인 Weight(가중치)와 그 밖의 학습 가능한 파라미터를 데이터에 맞게 반복적으로 조정한다.

반면 사용자가 ChatGPT와 같은 서비스에 질문을 입력할 때는 일반적으로 학습이 끝난 모델의 파라미터를 고정한 채, 입력에 대한 출력을 계산한다.

다만 실제 서비스에서는 대화 기록을 문맥으로 추가하거나, 검색 결과를 함께 제공하거나, 별도의 도구를 호출하는 등 모델 외부의 처리도 함께 수행될 수 있다. 이 글에서는 핵심적인 언어 모델의 학습과 자기회귀 추론에 초점을 맞춘다.

1. 먼저 알아야 할 것 — 컴퓨터는 언어를 숫자로 표현한다

사람에게

"나는 사과를 좋아한다."

라는 문장은 의미가 있다.

하지만 신경망의 계산 장치인 GPU는 문장의 의미를 직접 이해하지 않는다. 모델은 텍스트를 계산 가능한 숫자 표현으로 변환해 처리한다.

일반적인 흐름을 단순화하면 다음과 같다.

text

┌──────────────────────────────┐
│ "나는 사과를 좋아한다."       │
└──────────────┬───────────────┘
               ↓
          Tokenizer
               ↓
┌──────────────────────────────┐
│ ["나는", " 사과", "를",       │
│  " 좋아한다", "."]            │
└──────────────┬───────────────┘
               ↓
          Token ID
               ↓
┌──────────────────────────────┐
│ [102, 2048, 35, 7821, 13]     │
└──────────────┬───────────────┘
               ↓
       Token Embedding
               ↓
┌──────────────────────────────┐
│ [0.21, -0.73, 0.18, 0.92, …]  │
└──────────────┬───────────────┘
               ↓
          Transformer

실제 토큰 분할 결과와 Token ID는 사용하는 토크나이저와 모델에 따라 달라진다. 특히 현대의 토크나이저는 단어 단위가 아니라 단어의 일부, 공백이 포함된 문자열, 문자 조각 등을 토큰으로 만들 수 있다.

여기서 중요한 사실은 다음과 같다.

LLM은 텍스트를 숫자 표현으로 바꾸고, 그 숫자 표현에 대해 대규모 수학 연산을 수행하는 모델이다.

2. Tokenizer — 텍스트를 토큰으로 나눈다

LLM은 일반적으로 문장을 원문 그대로 처리하지 않는다.

먼저 **Tokenizer(토크나이저)*가 텍스트를 모델이 처리할 수 있는 작은 단위인 **Token(토큰)*의 시퀀스로 변환한다.

예를 들어 설명을 위해 단순화하면 다음과 같다.

text

"나는 사과를 좋아한다."
          ↓
["나는", " 사과", "를", " 좋아한다", "."]

하지만 실제 결과는 모델마다 다를 수 있다.

어떤 토크나이저는 단어 전체를 하나의 토큰으로 만들 수 있다.
어떤 토크나이저는 단어를 여러 조각으로 나눌 수 있다.
공백이나 문장 부호가 토큰에 포함될 수 있다.
한국어는 형태소, 음절, 문자 조각 등이 여러 방식으로 분할될 수 있다.

각 토큰에는 해당 모델의 Vocabulary 안에서 고유한 정수 번호가 부여된다.

text

나는        → 102
 사과       → 2048
를          → 35
 좋아한다   → 7821
.           → 13

위 숫자는 설명을 위한 예시일 뿐이며, 실제 모델의 ID와는 다르다.

따라서 모델이 직접 받는 입력은 대략 다음과 같은 정수 시퀀스다.

text

[102, 2048, 35, 7821, 13]

이것이 Token ID다.

Tokenizer는 단순히 문장을 띄어쓰기 기준으로 자르는 도구가 아니다. 텍스트를 모델의 Vocabulary에 정의된 토큰 시퀀스로 변환하고, 모델의 출력 토큰을 다시 텍스트로 복원하는 역할도 한다.

3. Embedding — Token ID를 벡터로 변환한다

사과 = 2048이라는 Token ID만으로는 사과의 의미를 표현할 수 없다.

Token ID는 의미를 나타내는 수치가 아니라 Vocabulary에서 토큰을 찾기 위한 인덱스에 가깝다.

그래서 모델은 Token ID를 고차원 벡터로 변환한다.

text

사과
 ↓
[0.21, -0.73, 0.18, 0.92, …]

이 벡터를 Token Embedding이라고 한다.

실제 차원 수는 모델에 따라 다르며 수백 차원에서 수천 차원 이상일 수 있다.

Embedding은 보통 학습 가능한 행렬에서 해당 Token ID의 행을 조회하는 방식으로 얻어진다. 즉, Token ID를 일반적인 의미의 숫자 크기로 해석하는 것이 아니라, 해당 ID에 대응하는 벡터를 찾아 사용하는 것이다.

중요한 점은 벡터의 각 좌표가 사람이 읽을 수 있는 특정 의미 하나와 일대일로 대응하지 않는다는 것이다.

학습이 진행되면서 모델은 토큰과 문맥의 관계를 표현하는 데 유용한 벡터와 내부 표현을 형성한다. 그 결과 의미나 사용 맥락이 비슷한 토큰들이 벡터 공간에서 일정한 관계를 보일 수 있다.

다만 다음과 같이 단순한 2차원 지도처럼 모든 의미가 명확하게 분리되어 저장된다고 이해해서는 안 된다.

text

       사과 ─── 바나나
        │
        │
       과일

자동차 ─── 버스
    │
    │
  교통수단

현대 Transformer에서는 입력 Embedding만으로 모든 의미가 결정되는 것이 아니다. 여러 Transformer 층을 통과하면서 문맥에 따라 표현이 계속 변한다. 따라서 같은 토큰도 주변 문맥에 따라 최종적인 내부 표현이 달라질 수 있다.

4. Position — 토큰의 순서와 위치를 표현한다

Self-Attention은 기본적으로 입력 토큰 사이의 관계를 계산하지만, 토큰의 순서 자체를 자동으로 알 수 있는 구조는 아니다.

다음 두 문장을 생각해보자.

철수가 영희를 때렸다.

영희가 철수를 때렸다.

사용된 토큰이 비슷하더라도 순서와 문법적 역할이 달라 의미가 달라진다.

따라서 모델은 토큰의 내용뿐 아니라 위치와 순서에 관한 정보도 사용해야 한다.

이를 위해 모델 구조에 따라 다양한 위치 표현 방식이 사용된다.

절대 위치 임베딩
학습 가능한 위치 임베딩
사인·코사인 기반 Positional Encoding
상대 위치 표현
RoPE(Rotary Position Embedding)
ALiBi와 같은 위치 편향 방식

RoPE는 현대적인 LLM에서 널리 사용되는 방식 중 하나지만, 모든 LLM이 RoPE를 사용하는 것은 아니다.

핵심은 다음과 같다.

모델은 토큰의 내용에 관한 표현과 토큰의 위치·순서에 관한 정보를 함께 사용한다.

여기까지는 Training과 Inference 모두에서 사용된다

이 부분은 매우 중요하다.

Tokenizer, Token Embedding, 위치 정보, Transformer 계산은 학습과 추론 모두에서 사용된다.

다만 학습과 추론의 입력 형태와 계산 방식에는 차이가 있을 수 있다.

학습에서는 여러 위치의 다음 토큰을 한 번에 계산하는 병렬 처리가 일반적이다.
생성 추론에서는 이미 생성된 토큰을 바탕으로 다음 토큰을 순차적으로 계산한다.
추론에서는 일반적으로 Gradient를 계산하지 않고, 파라미터를 수정하지 않는다.

전체 흐름을 단순화하면 다음과 같다.

text

                         입력 텍스트
                              ↓
                          Tokenizer
                              ↓
                           Token ID
                              ↓
                       Token Embedding
                              ↓
                        위치 정보 반영
                              ↓
                         Transformer
                              ↓
              ┌───────────────┴───────────────┐
              │                               │
          Training                         Inference
              │                               │
       정답 토큰과 비교                 다음 토큰 분포 계산
              │                               │
             Loss                         선택 또는 결정
              ↓                               ↓
       Backpropagation                  다음 토큰 생성
              ↓                               ↓
           Gradient                 문맥에 추가하여 반복
              ↓
          Optimizer
              ↓
        파라미터 수정

즉,

입력을 표현하고 Transformer를 통과시키는 부분은 학습과 추론에 공통으로 존재하지만, 학습은 손실을 이용해 파라미터를 수정하고 추론은 파라미터를 사용해 출력을 생성한다.

PART 1 🧠 Training — 모델의 파라미터를 학습하는 과정

학습의 목적은 데이터에 포함된 패턴을 바탕으로 주어진 문맥에서 적절한 다음 토큰의 확률을 높이도록 모델의 파라미터를 조정하는 것이다.

현대 LLM의 사전학습에서는 대체로 다음 토큰 예측(Next-Token Prediction)을 사용한다.

다만 모든 LLM 학습이 동일한 것은 아니다. 사전학습 이후에는 지도 미세 조정, 선호도 학습, 강화학습 또는 그와 유사한 최적화 절차가 추가될 수 있다. 여기서는 가장 기본적인 자기회귀 언어 모델의 사전학습을 중심으로 설명한다.

5. Training의 시작 — 입력과 정답을 만든다

학습 데이터가 다음과 같다고 해보자.

원숭이 엉덩이는 빨개

이를 토큰으로 변환한 결과가 다음과 같다고 가정하자.

text

[원숭이, 엉덩이는, 빨개]

자기회귀 언어 모델은 각 위치에서 다음 토큰을 예측하도록 학습할 수 있다.

text

┌──────────────────────────┬──────────────────┐
│ 입력 문맥                 │ 정답 다음 토큰    │
├──────────────────────────┼──────────────────┤
│ [원숭이]                  │ 엉덩이는          │
│ [원숭이, 엉덩이는]        │ 빨개              │
└──────────────────────────┴──────────────────┘

실제 학습에서는 효율성을 위해 전체 시퀀스를 한 번에 입력하고, 각 위치의 출력과 한 칸 이동한 정답 시퀀스를 비교하는 teacher forcing 방식이 일반적으로 사용된다.

예를 들어 다음과 같이 생각할 수 있다.

text

입력:  [원숭이, 엉덩이는]
정답:  [엉덩이는, 빨개]

문장 끝에는 EOS(End of Sequence) 토큰이 추가될 수도 있다.

따라서 학습은 단순히 문장 전체를 한 번 보고 마지막 단어 하나만 맞히는 과정이 아니라, 하나의 시퀀스 안에서 여러 위치의 다음 토큰 예측을 동시에 학습하는 과정이다.

6. Forward Pass — 현재 파라미터로 예측한다

현재 모델의 파라미터를 이용해 입력을 Transformer에 통과시킨다.

text

입력 Token ID
      ↓
Token Embedding
      ↓
위치 정보 반영
      ↓
Transformer
      ↓
각 위치의 Logits

예를 들어 특정 위치에서 다음 토큰에 대한 모델의 확률이 다음과 같다고 해보자.

text

노래     40%
빨개     10%
길어      8%
맛있다    3%
...

정답이 빨개라면 이 예측은 충분히 좋지 않을 수 있다.

이때 수행되는 계산을 Forward Pass(순전파)라고 한다.

정확히 말하면 Forward Pass의 직접적인 출력은 보통 Vocabulary 전체에 대한 Logits이며, 필요에 따라 Softmax를 적용해 확률로 해석한다.

Forward Pass는 현재 파라미터와 입력을 이용해 모델의 출력을 계산하는 과정이다.

7. Loss — 예측과 정답의 차이를 수치화한다

모델의 예측과 실제 정답을 비교한다.

정답 토큰이 빨개라고 하자.

text

빨개 확률 90%
→ 일반적으로 Loss가 작음

빨개 확률 10%
→ 일반적으로 Loss가 큼

이처럼 모델의 출력이 정답과 얼마나 다른지를 수치로 나타내는 것이 Loss(손실)다.

자기회귀 언어 모델의 다음 토큰 예측에서는 일반적으로 Cross-Entropy Loss 또는 그와 동등한 Negative Log-Likelihood를 사용한다.

정답 토큰의 예측 확률을 p라고 하면 한 위치의 손실은 다음과 같이 표현할 수 있다.

text

L = -log(p)

정답 토큰에 높은 확률을 부여할수록 손실은 작아지고, 낮은 확률을 부여할수록 손실은 커진다.

실제 구현에서는 수치 안정성을 위해 Logits에 직접 LogSoftmax와 Negative Log-Likelihood를 적용하거나, 이에 해당하는 Cross-Entropy 연산을 사용한다. 따라서 학습 과정에서 반드시 확률을 명시적으로 계산해 저장해야 하는 것은 아니다.

여러 토큰 위치와 여러 학습 샘플의 손실을 평균하거나 합산해 전체 학습 손실을 만든다.

Loss는 현재 모델이 학습 목표를 얼마나 잘 수행하고 있는지를 나타내는 목적 함수다.

8. Backpropagation — 손실이 파라미터에 미친 영향을 계산한다

모델에는 수십억 개 이상의 파라미터가 있을 수 있다.

그렇다면 다음과 같은 질문이 생긴다.

"이 많은 파라미터 중 어떤 값을 어느 방향으로 바꿔야 하는가?"

여기서 Backpropagation(역전파)이 사용된다.

역전파는 손실 함수에서 시작해 계산 그래프를 거꾸로 따라가며 각 파라미터가 손실에 미친 영향을 계산한다.

text

Loss
 ↓
계산 그래프를 역방향으로 통과
 ↓
각 파라미터에 대한 미분값 계산

그 핵심에는 미분과 연쇄법칙이 있다.

역전파 자체는 파라미터를 수정하는 단계가 아니다. 역전파는 파라미터에 대한 Gradient를 계산하는 절차이고, 실제 수정은 Optimizer가 수행한다.

9. Gradient — 파라미터를 어느 방향으로 바꿀지 알려준다

역전파를 수행하면 각 파라미터에 대한 Gradient(기울기)가 계산된다.

Gradient는 다음과 같은 의미를 가진다.

현재 파라미터를 아주 조금 바꿀 때 손실이 어느 방향으로 얼마나 변하는지를 나타내는 값

예를 들어 다음과 같은 값이 계산될 수 있다.

text

Weight A
Gradient = +0.8

Weight B
Gradient = -0.2

Gradient가 양수라면 해당 파라미터를 증가시킬 때 손실이 커지는 방향이라는 뜻이고, 음수라면 증가시킬 때 손실이 작아지는 방향이라는 뜻이다. 따라서 손실을 줄이기 위해서는 기본적인 경사하강법에서 Gradient의 반대 방향으로 파라미터를 이동한다.

다만 실제 학습에서는 Gradient의 크기와 방향이 파라미터마다 다르고, 여러 샘플의 Gradient를 미니배치 단위로 평균하거나 합산해 사용한다.

10. Optimizer — Gradient를 이용해 파라미터를 업데이트한다

Gradient가 계산됐다고 해서 학습이 끝나는 것은 아니다.

이제 Gradient를 이용해 파라미터를 실제로 얼마나 업데이트할지 결정해야 한다.

이 역할을 하는 것이 Optimizer(옵티마이저)다.

대표적인 Optimizer로는 SGD, Adam, AdamW 등이 있다.

가장 단순한 경사하강법은 다음과 같이 표현할 수 있다.

text

새로운 파라미터
=
기존 파라미터
-
학습률 × Gradient

Adam이나 AdamW는 여기에 Gradient의 이동 평균, 제곱 이동 평균, 가중치 감쇠 등 추가적인 메커니즘을 사용한다. 따라서 실제 업데이트가 항상 위의 단순한 식과 정확히 같지는 않다.

또한 학습 중에는 Gradient Clipping, Learning Rate Scheduler, Weight Decay, Mixed Precision 등의 기법이 함께 사용될 수 있다.

11. Learning Rate — 한 번에 얼마나 업데이트할 것인가?

Learning Rate(학습률)는 파라미터를 한 번의 업데이트에서 얼마나 크게 움직일지를 결정하는 중요한 하이퍼파라미터다.

목적지를 향해 이동하는 상황에 비유하면 다음과 같다.

text

┌──────────────┬──────────────────────────────────────┐
│ 너무 큼       │ 최적화가 불안정해질 수 있음           │
│              │ 좋은 지점을 지나치거나 발산할 수 있음 │
├──────────────┼──────────────────────────────────────┤
│ 적절함       │ 비교적 안정적으로 손실을 줄임          │
├──────────────┼──────────────────────────────────────┤
│ 너무 작음    │ 학습이 매우 느림                       │
│              │ 충분히 학습되기 전에 멈출 수 있음      │
└──────────────┴──────────────────────────────────────┘

다만 학습률이 크다고 항상 나쁜 것도 아니고 작다고 항상 좋은 것도 아니다. 모델 구조, 배치 크기, Optimizer, 학습률 스케줄, 데이터와 초기화 등에 따라 적절한 값이 달라진다.

12. 이 과정을 미니배치와 여러 단계에 걸쳐 반복한다

실제 학습은 한 번에 데이터 하나만 처리하는 방식이 아니라, 여러 샘플을 묶은 미니배치를 사용해 진행하는 경우가 일반적이다.

전체 흐름은 다음과 같다.

text

┌──────────────────────┐
│ 학습 데이터           │
└──────────┬───────────┘
           ↓
      Tokenizer
           ↓
        Token ID
           ↓
    Token Embedding
           ↓
     위치 정보 반영
           ↓
      Transformer
           ↓
         Logits
           ↓
       Loss 계산
           ↓
   Backpropagation
           ↓
    Gradient 계산
           ↓
       Optimizer
           ↓
    파라미터 업데이트
           ↓
      다음 미니배치
           ↓
         반복

이 과정을 수많은 미니배치와 학습 단계에 걸쳐 반복한다.

학습이 진행되면서 모델의 파라미터는 데이터에 나타나는 언어적·통계적 패턴을 더 잘 예측하도록 조정된다.

다만 학습 손실이 낮아진다고 해서 모델이 모든 사실을 정확히 기억하거나 인간처럼 이해한다는 뜻은 아니다. 모델은 데이터의 패턴을 학습하며, 학습 데이터의 품질과 분포, 모델 구조, 최적화 방식에 따라 성능과 한계가 결정된다.

13. Training의 결과 — 학습된 파라미터를 저장한다

학습이 끝나면 모델의 파라미터를 저장한다.

text

Training

파라미터
   ↓
업데이트
   ↓
업데이트
   ↓
업데이트
   ↓
  ...
   ↓
학습 완료

학습이 완료된 모델을 추론에 사용할 때는 일반적으로 파라미터를 고정하고 Gradient 계산과 Optimizer 업데이트를 수행하지 않는다.

다만 "완성된 Weight"라는 표현은 설명을 위한 단순화다. 실제로는 다음과 같은 요소도 모델 파일이나 실행 환경에 함께 필요할 수 있다.

모델 구조와 설정
Tokenizer와 Vocabulary
위치 표현 방식
특수 토큰 정보
파라미터의 데이터 형식
양자화 설정
추론용 런타임 정보

따라서 학습된 모델은 단순한 숫자 파일 하나라기보다, 파라미터와 구조·토크나이저 설정이 결합된 실행 가능한 모델 구성으로 이해하는 것이 정확하다.

PART 2 ⚡ Inference — 학습된 모델로 출력을 계산하는 과정

이제 Inference(추론)를 살펴보자.

추론은 이미 학습된 모델의 파라미터를 사용해 새로운 입력에 대한 출력을 계산하는 과정이다.

일반적인 생성 추론에서는 다음과 같은 특징이 있다.

파라미터를 업데이트하지 않는다.
Gradient를 계산하지 않는다.
Optimizer를 사용하지 않는다.
모델은 입력 문맥에 대한 다음 토큰 분포를 계산한다.
생성 모델에서는 선택된 토큰을 문맥에 추가하고 다음 토큰을 다시 계산한다.

실제 구현에서는 메모리와 속도를 위해 inference mode, no_grad, 적절한 데이터 형식, 배치 처리 등을 사용한다.

14. 사용자가 질문을 입력한다

사용자가 다음과 같이 입력했다고 해보자.

대한민국의 수도는

먼저 입력 텍스트를 Tokenizer로 변환한다.

text

대한민국의 수도는
       ↓
    Tokenizer
       ↓
   Token ID
       ↓
Token Embedding
       ↓
위치 정보 반영

실제 Token ID와 토큰 분할은 모델마다 다르다.

그 후 이 표현이 Transformer에 입력된다.

15. Transformer — 학습된 파라미터로 계산한다

Inference에서는 학습이 끝난 파라미터를 사용해 입력을 계산한다.

text

입력 표현
   ↓
Transformer
   ↓
출력 표현
   ↓
LM Head
   ↓
다음 토큰에 대한 Logits

여기서 LM Head(Language Modeling Head)는 Transformer의 최종 은닉 상태를 Vocabulary 크기의 Logits로 변환하는 출력층이다. 많은 언어 모델에서는 LM Head의 가중치를 입력 Embedding과 공유하기도 하지만, 모든 모델이 반드시 공유하는 것은 아니다.

Training에서는 이 출력과 정답을 비교해 손실을 계산하고 파라미터를 업데이트한다.

Inference에서는 일반적으로 손실을 계산하거나 파라미터를 업데이트하지 않는다. 단지 현재 파라미터를 이용해 출력을 계산한다.

16. Attention — 문맥 안의 토큰 관계를 계산한다

Transformer의 핵심 구성 요소 중 하나가 Self-Attention이다.

예를 들어 다음 문장을 생각해보자.

철수가 사과를 먹었다. 그것은 맛있었다.

모델은 그것을 처리할 때 앞의 여러 토큰과의 관계를 계산할 수 있다.

설명을 위해 단순화하면 다음과 같이 표현할 수 있다.

text

현재 토큰: 그것

철수       0.05
사과       0.82
먹었다     0.10
맛있었다   0.03

하지만 이 숫자는 실제 모델이 직접 출력하는 고정된 "단어별 의미 점수"가 아니다. Attention은 각 층과 각 Head에서 서로 다른 방식으로 계산되며, 문맥과 위치에 따라 값이 달라진다. 위 표는 단지 특정 토큰이 다른 토큰의 정보를 얼마나 참고하는지를 설명하기 위한 개념적 예시다.

또한 Causal Language Model에서는 현재 위치의 토큰이 미래 위치의 토큰을 미리 볼 수 없도록 Causal Mask를 적용한다.

17. Query, Key, Value

Attention을 이해하면 Q(Query), K(Key), V(Value)라는 용어가 등장한다.

검색 시스템에 비유하면 다음과 같이 이해할 수 있다.

text

Query
→ 현재 위치가 찾고 있는 정보

Key
→ 각 위치가 어떤 정보와 관련 있는지 판단하기 위한 표현

Value
→ 실제로 가중합해 가져올 정보

입력 은닉 상태를 선형 변환해 Query, Key, Value를 만든다.

Scaled Dot-Product Attention은 개념적으로 다음 순서로 계산된다.

text

Query와 Key의 유사도 계산
          ↓
        스케일링
          ↓
       마스크 적용
          ↓
         Softmax
          ↓
    Attention 가중치
          ↓
      Value의 가중합

대표적인 수식은 다음과 같다.

text

Attention(Q, K, V)
=
softmax((QKᵀ / √dₖ) + M)V

여기서 dₖ는 Key 벡터의 차원이고, M은 필요할 경우 미래 위치를 가리는 마스크다. 구현에 따라 마스크는 별도의 항으로 적용되거나, 허용되지 않는 위치의 점수를 매우 작은 값으로 설정하는 방식으로 처리된다.

Multi-Head Attention에서는 여러 개의 Head가 서로 다른 투영 공간에서 Attention을 계산한 뒤 결과를 결합한다.

18. Transformer Block을 여러 번 통과한다

실제 LLM은 Attention 한 번으로 끝나지 않는다.

여러 개의 Transformer Block을 쌓아 사용한다.

일반적인 Decoder-only Transformer Block에는 다음과 같은 요소가 포함된다.

Causal Self-Attention
Feed-Forward Network 또는 MLP
Residual Connection
Layer Normalization 또는 RMSNorm
경우에 따라 Gated MLP 등 변형 구조

개념적으로는 다음과 같다.

text

입력
 ↓
정규화
 ↓
Causal Self-Attention
 ↓
Residual Connection
 ↓
정규화
 ↓
FFN 또는 MLP
 ↓
Residual Connection
 ↓
다음 Transformer Block
 ↓
...
 ↓
최종 은닉 상태
 ↓
LM Head

구체적인 순서와 구성은 모델 아키텍처에 따라 달라질 수 있다.

여러 층을 통과하면서 각 위치의 표현은 주변 문맥과 상호작용하고, 더 복잡한 언어적·구조적 패턴을 반영하는 방향으로 변환된다.

19. Logits — Vocabulary 각 토큰에 대한 원시 점수

Transformer의 최종 은닉 상태는 바로 사람이 읽을 수 있는 문장이 아니다.

LM Head는 다음 토큰으로 가능한 Vocabulary의 각 토큰에 대해 점수를 계산한다.

예를 들어 다음과 같은 값이 나올 수 있다.

text

서울       12.4
부산        8.1
도쿄        3.2
런던        1.8
자동차     -2.3
...

이 값을 Logit(로짓)이라고 한다.

Logit은 확률이 아니다.

각 토큰의 상대적인 선호도를 나타내는 실수 점수이며, 모든 Logit에 같은 상수를 더해도 Softmax 결과는 변하지 않는다. 따라서 Logit의 절대적인 값 자체보다 토큰 간 상대적인 차이가 중요하다.

다음 토큰의 Logits는 일반적으로 마지막 입력 위치에 해당하는 출력에서 가져온다. 학습에서는 모든 위치의 Logits를 사용해 여러 다음 토큰 예측 손실을 계산할 수 있다.

20. Softmax — Logits를 확률 분포로 변환한다

Logits를 확률로 해석하려면 Softmax를 적용한다.

text

pᵢ = exp(zᵢ) / Σⱼ exp(zⱼ)

여기서 zᵢ는 토큰 i의 Logit이고, pᵢ는 해당 토큰의 확률이다.

예를 들어 설명을 위해 다음과 같이 나타낼 수 있다.

text

Logit

서울       12.4
부산        8.1
도쿄        3.2
런던        1.8

       ↓ Softmax

서울       96%
부산        3%
도쿄        0.7%
런던        0.3%
...

실제 확률은 전체 Vocabulary의 모든 Logit과 계산 방식에 따라 결정되므로 위 수치는 설명을 위한 예시다.

Softmax 결과는 전체 합이 1인 확률 분포다.

모델은 입력 문맥이 주어졌을 때 Vocabulary의 각 토큰이 다음에 올 상대적 가능성을 나타내는 분포를 계산한다.

21. Sampling — 확률 분포에서 다음 토큰을 선택한다

다음 토큰을 선택하는 방법은 하나뿐이 아니다.

대표적인 방법은 다음과 같다.

Greedy Decoding: 가장 높은 확률의 토큰을 선택
Sampling: 확률 분포에 따라 무작위로 선택
Beam Search: 여러 후보 시퀀스를 유지하며 탐색
Temperature Scaling
Top-K Sampling
Top-P 또는 Nucleus Sampling

대화형 LLM의 생성에서는 Greedy Decoding이나 Sampling이 주로 사용되며, 구체적인 방식은 서비스와 설정에 따라 다르다.

항상 확률 1위 토큰만 선택하면 결과가 안정적일 수 있지만, 표현이 반복적이거나 지나치게 결정적일 수 있다. Sampling을 사용하면 확률이 높은 후보를 중심으로 다양한 결과가 나올 수 있다.

다만 Sampling이 항상 더 좋은 것은 아니다. 사실성, 일관성, 창의성, 반복 억제 등 목표에 따라 적절한 디코딩 전략이 달라진다.

22. Temperature — Logits 분포의 날카로움을 조절한다

Temperature는 보통 Softmax를 적용하기 전에 Logits를 나누는 방식으로 사용한다.

text

pᵢ = softmax(zᵢ / T)

여기서 T가 Temperature다.

T = 1: 원래 Logits를 사용
T < 1: 높은 Logit에 더 집중하는 분포
T > 1: 분포가 더 평평해지는 경향

개념적으로는 다음과 같다.

text

┌──────────────────────┬────────────────────────────────────┐
│ 낮은 Temperature      │ 높은 확률 후보에 집중               │
│                      │ 출력의 변동성 감소                   │
│                      │ 결정적인 출력에 유리할 수 있음       │
├──────────────────────┼────────────────────────────────────┤
│ 높은 Temperature      │ 여러 후보의 확률 차이가 완화됨      │
│                      │ 출력의 다양성 증가                   │
│                      │ 부적절하거나 불안정한 선택도 늘 수 있음 │
└──────────────────────┴────────────────────────────────────┘

Temperature는 확률을 단순히 일정 비율로 늘리거나 줄이는 기능이 아니다. Softmax 이전의 Logits를 조정해 확률 분포의 형태를 바꾸는 방식이다.

또한 Temperature가 높다고 항상 창의성이 높아지는 것은 아니며, 모델과 프롬프트, 후보 분포에 따라 결과가 달라진다.

23. Top-K — 확률이 높은 K개 후보만 남긴다

Top-K Sampling은 확률 또는 Logit이 높은 K개의 후보만 남긴 뒤, 나머지 후보를 제외하고 그 안에서 다시 확률을 정규화해 샘플링하는 방식이다.

예를 들어 Top-K가 40이라면 다음과 같다.

text

전체 Vocabulary
       ↓
점수가 높은 40개 후보 선택
       ↓
나머지 후보 제거
       ↓
남은 후보의 확률 재정규화
       ↓
그 안에서 Sampling

Top-K는 항상 고정된 개수의 후보를 남긴다는 특징이 있다.

24. Top-P — 누적 확률 질량을 기준으로 후보를 남긴다

Top-P 또는 Nucleus Sampling은 확률이 높은 후보부터 누적해 일정한 확률 질량 P를 구성하는 최소 후보 집합을 만든 뒤, 그 집합 안에서 샘플링하는 방식이다.

예를 들어 다음과 같은 분포가 있다고 하자.

text

서울   60%
부산   20%
대구   10%
인천    5%
기타    5%

Top-P가 0.9라면 누적 확률이 90% 이상이 되도록 하는 후보 집합을 선택한다.

text

서울   60%  → 누적 60%
부산   20%  → 누적 80%
대구   10%  → 누적 90%

따라서 이 예시에서는 서울, 부산, 대구가 후보가 된다.

실제 구현에서는 경계 후보를 포함하는 방식과 필터링 순서에 관한 세부 차이가 있을 수 있다.

Top-K와 Top-P의 차이는 다음과 같다.

Top-K = 후보를 몇 개 남길 것인가

Top-P = 누적 확률 질량을 어느 정도 남길 것인가

25. 다음 토큰 하나가 선택된다

이제 디코딩 규칙에 따라 실제 다음 토큰 하나를 선택한다.

예를 들어 다음과 같이 생성될 수 있다.

text

대한민국의 수도는
        ↓
       서울

여기서 서울은 하나의 토큰일 수도 있고, 특정 토크나이저에서는 여러 토큰의 일부일 수도 있다. 사람에게 보이는 단어와 모델이 선택하는 토큰은 항상 일치하지 않는다.

26. Autoregressive Generation — 생성한 토큰을 문맥에 추가한다

자기회귀 언어 모델은 지금까지의 문맥을 바탕으로 다음 토큰을 예측하고, 선택한 토큰을 다시 문맥에 추가한다.

text

대한민국의 수도는
          ↓
대한민국의 수도는 서울

그다음 다시 다음 토큰의 분포를 계산한다.

text

대한민국의 수도는 서울
          ↓
        입니다

그리고 다시 다음 토큰을 계산한다.

text

대한민국의 수도는 서울입니다
          ↓
          .

이 과정을 종료 조건이 충족될 때까지 반복한다.

종료 조건에는 다음과 같은 것이 포함될 수 있다.

EOS 토큰 생성
최대 출력 토큰 수 도달
서비스가 정한 중지 문자열 생성
외부 제어 로직에 의한 중단

이를 Autoregressive Generation(자기회귀 생성)이라고 한다.

자기회귀 생성은 지금까지 생성된 토큰을 다음 예측의 입력 문맥으로 다시 사용하는 방식이다.

27. LLM은 문장을 한 번에 완성하는 것이 아니다

사용자에게는 LLM이 질문에 대한 답변을 한 번에 만들어내는 것처럼 보일 수 있다.

하지만 자기회귀 생성 모델의 기본적인 생성 과정은 다음과 같다.

text

현재 문맥으로 다음 토큰 분포 계산
              ↓
          다음 토큰 선택
              ↓
            문맥에 추가
              ↓
현재 문맥으로 다음 토큰 분포 계산
              ↓
            반복

따라서 생성 속도는 흔히 tokens per second(tokens/s)로 표현한다.

다만 실제 시스템에서는 여러 요청을 배치로 처리하거나, Speculative Decoding과 같은 최적화 기법을 사용해 여러 토큰을 효율적으로 검증할 수 있다. 이러한 최적화가 있더라도 기본적인 언어 모델의 확률 구조는 다음 토큰 예측을 중심으로 한다.

28. KV Cache — 이전 Attention 계산을 재사용한다

자기회귀 생성에서는 새로운 토큰을 하나씩 추가한다.

이때 매번 전체 문맥을 처음부터 다시 계산하면 비효율적이다.

Transformer의 Self-Attention에서는 각 층에서 이전 토큰에 대한 Key와 Value를 계산한다. 생성 과정에서는 이미 처리한 토큰의 Key와 Value를 저장해 두고, 새 토큰을 계산할 때 재사용할 수 있다.

이를 KV Cache라고 한다.

개념적으로는 다음과 같다.

text

첫 번째 토큰
   ↓
각 층의 K/V 저장

두 번째 토큰
   ↓
이전 K/V 재사용
새 토큰의 K/V 추가 저장

세 번째 토큰
   ↓
이전 K/V 재사용
새 토큰의 K/V 추가 저장

...

새로 생성되는 토큰은 이전 토큰을 참고할 수 있지만, Causal Mask 때문에 미래 토큰을 참고할 수 없다.

KV Cache를 사용하면 매 단계마다 과거 토큰의 Key와 Value를 다시 계산하지 않아도 된다. 다만 새 토큰의 Query와 새 Key·Value는 계산해야 한다.

KV Cache는 생성 속도를 높이는 데 도움이 되지만, 문맥 길이와 배치 크기에 따라 상당한 GPU 메모리를 사용한다. 따라서 긴 문맥을 처리할 때는 KV Cache의 메모리 사용량이 중요한 시스템 설계 요소가 된다.

학습에서도 Key와 Value를 저장하는 최적화가 사용될 수 있지만, 일반적인 학습은 전체 시퀀스를 병렬로 처리하고 역전파를 위해 훨씬 많은 중간 활성값을 저장하므로, 생성 추론에서 설명하는 KV Cache와 목적과 사용 방식이 다르다.

29. Training과 Inference의 결정적인 차이

이제 주요 개념을 비교해보자.

구분	Training	Inference
목적	데이터에 맞게 모델 파라미터를 학습함	학습된 모델로 출력을 계산함
Tokenizer	사용	사용
Token Embedding	사용	사용
위치 정보	사용	사용
Transformer	사용	사용
Attention	사용	사용
FFN 또는 MLP	사용	사용
Forward Pass	사용	사용
Loss	정답과 비교하기 위해 사용	일반적인 생성 추론에서는 사용하지 않음
Backpropagation	사용	일반적인 생성 추론에서는 사용하지 않음
Gradient	계산	일반적인 생성 추론에서는 계산하지 않음
Optimizer	파라미터 업데이트에 사용	사용하지 않음
파라미터	반복적으로 업데이트됨	일반적으로 고정됨
Logits	계산됨	계산됨
Softmax	손실 계산이나 확률 해석에 사용될 수 있음	토큰 선택을 위해 사용될 수 있음
Sampling	기본적인 교사 강요 학습의 핵심은 아님	생성 방식에 따라 사용
Autoregressive 처리	학습에서는 여러 위치를 병렬 처리하는 경우가 일반적	생성에서는 토큰을 순차적으로 추가
KV Cache	일반적인 학습과 생성 추론에서 목적과 사용 방식이 다름	자기회귀 생성에서 매우 중요
메모리 사용	파라미터, Gradient, Optimizer 상태, 활성값 등으로 큼	파라미터와 KV Cache 등이 주요 요소
핵심 질문	"파라미터를 어떻게 바꿔야 손실이 줄어드는가?"	"현재 문맥에서 다음에 무엇을 출력할 것인가?"

여기서 몇 가지를 주의해야 한다.

첫째, Training에서도 Forward Pass는 수행된다. Inference는 사실상 Gradient와 파라미터 업데이트가 없는 Forward 계산으로 볼 수 있다.

둘째, Training에서 Softmax를 개념적으로 설명할 수 있지만, 실제 구현은 수치 효율성을 위해 Logits에 직접 Cross-Entropy를 적용할 수 있다.

셋째, Sampling은 일반적인 다음 토큰 예측 학습의 핵심 단계가 아니다. 학습에서는 정답 토큰을 사용해 손실을 계산하는 teacher forcing이 일반적이다. Sampling은 주로 생성 추론에서 사용된다.

넷째, 모든 LLM이 동일한 학습 목표와 구조를 사용하는 것은 아니다. 이 표는 전형적인 Decoder-only 자기회귀 언어 모델을 기준으로 한 것이다.

30. 전체 흐름을 하나로 연결하면

이제 LLM의 학습과 추론을 하나의 그림으로 연결해보자.

text

┌─────────────────────┐
│      학습 데이터      │
└──────────┬──────────┘
           ↓
      Tokenizer
           ↓
        Token ID
           ↓
    Token Embedding
           ↓
      위치 정보 반영
           ↓
┌────────────────────┐
│    Transformer      │
│                    │
│  Attention         │
│       ↓            │
│  FFN / MLP         │
└─────────┬──────────┘
          ↓
    각 위치의 Logits
          ↓
정답 토큰과 Cross-Entropy
          ↓
         Loss
          ↓
  Backpropagation
          ↓
       Gradient
          ↓
       Optimizer
          ↓
   파라미터 업데이트
          │
          └──────────────┐
                         ↓
                 수많은 학습 단계
                         ↓
                 ┌─────────────┐
                 │ 학습된 모델  │
                 │ 파라미터    │
                 └──────┬──────┘
                        │
════════════════════════╪════════════════════════
                        │
                 여기서부터 Inference
                        │
                        ↓
                 사용자 Prompt
                        ↓
                    Tokenizer
                        ↓
                     Token ID
                        ↓
                 Token Embedding
                        ↓
                  위치 정보 반영
                        ↓
                   Transformer
                        ↓
                     LM Head
                        ↓
                     Logits
                        ↓
              Decoding / Sampling
                        ↓
                   다음 Token
                        ↓
               문맥에 토큰 추가
                        ↓
                 다음 Token 계산
                        ↓
                      반복
                        ↓
                    최종 텍스트

31. 같은 Transformer를 사용하지만 목적과 실행 방식이 다르다

Training과 Inference 모두 다음과 같은 핵심 계산을 공유한다.

text

Tokenization
      ↓
Embedding
      ↓
Position 정보
      ↓
Transformer
      ↓
Logits

하지만 그 결과를 사용하는 방식이 다르다.

Training에서는 다음과 같다.

text

Logits
  ↓
정답 토큰과 비교
  ↓
Loss
  ↓
Backpropagation
  ↓
Gradient
  ↓
Optimizer
  ↓
파라미터 업데이트

Inference에서는 다음과 같다.

text

Logits
  ↓
Decoding
  ↓
다음 Token 선택
  ↓
문맥에 추가
  ↓
다음 Token 계산

즉,

같은 모델 계산을 사용하지만, Training은 손실을 이용해 파라미터를 바꾸는 과정이고 Inference는 파라미터를 바꾸지 않은 채 출력을 계산하는 과정이다.

또한 학습에서는 teacher forcing을 통해 정답 시퀀스를 기준으로 여러 위치의 예측을 병렬 계산하는 것이 일반적이다. 반면 생성 추론에서는 모델이 방금 생성한 토큰을 다음 입력 문맥에 포함시키므로 순차적인 의존성이 생긴다.

32. 그렇다면 LLM의 지식은 어디에 저장되어 있을까?

여기서 중요한 질문이 나온다.

"학습한 지식은 모델의 어디에 저장되는가?"

책처럼

text

서울 = 대한민국의 수도

라는 문장이 파일의 특정 위치에 그대로 저장되어 있는 것은 아니다.

학습 과정에서 데이터의 통계적 패턴과 관계를 잘 예측하도록 모델의 파라미터가 조정된다.

학습된 모델의 핵심은 다음과 같은 거대한 파라미터 집합이다.

text

파라미터 1
파라미터 2
파라미터 3
...
수십억~수천억 개 이상의 파라미터

이 파라미터와 모델 구조가 입력을 어떻게 변환하고 어떤 다음 토큰 분포를 출력할지를 결정한다.

따라서 흔히 다음과 같이 표현한다.

"모델의 지식은 파라미터에 녹아 있다."

다만 이 표현은 단순화된 설명이다.

지식은 특정 한 개의 파라미터에 저장되지 않는다.
여러 층과 여러 파라미터에 분산된 표현으로 나타난다.
모델은 데이터베이스처럼 문장을 정확히 조회하는 방식으로만 작동하지 않는다.
학습 데이터의 문장을 일부 암기할 수도 있으며, 일반화와 암기가 함께 나타날 수 있다.
모델의 출력은 파라미터뿐 아니라 입력 문맥, 시스템 지시, 검색 결과, 도구 사용, 디코딩 설정 등의 영향을 받을 수 있다.

따라서 더 정확하게 말하면 다음과 같다.

LLM의 학습된 능력과 지식은 주로 파라미터와 네트워크의 계산 구조에 분산되어 표현되며, 입력 문맥과 추론 절차를 통해 출력으로 나타난다.

33. 그렇다면 LLM은 결국 '확률 계산기'인가?

어느 정도는 맞는 표현이지만, 충분한 설명은 아니다.

LLM은 최종적으로 다음 토큰에 대한 확률 분포를 출력한다. 그러나 그 분포를 만들기까지 여러 층의 Transformer가 입력 문맥을 변환하고, Attention과 MLP가 다양한 관계와 패턴을 계산한다.

따라서 LLM을 단순히 "다음 단어 하나를 찍는 기계"라고만 설명하면 내부 계산의 복잡성을 지나치게 축소하게 된다.

또한 모델이 출력하는 것은 엄밀히 말해 다음 단어가 아니라 다음 토큰이다. 토큰은 단어 전체일 수도 있고, 단어의 일부나 공백·문장 부호를 포함한 조각일 수도 있다.

가장 단순화하면 다음과 같이 표현할 수 있다.

text

텍스트
  ↓
토큰
  ↓
Token ID
  ↓
벡터 표현
  ↓
Transformer의 행렬 연산
  ↓
Attention과 MLP
  ↓
Logits
  ↓
다음 토큰 분포
  ↓
디코딩
  ↓
다음 Token

다만 "확률"은 모델이 현실 세계의 진실성을 직접 측정한 값이 아니다. 모델이 학습한 분포와 현재 문맥에 따라 다음 토큰이 나타날 상대적 가능성을 나타내는 값이다. 따라서 높은 확률의 출력이 항상 사실이라는 보장은 없다.

34. 그래서 LLM을 이해하는 가장 좋은 방법

처음부터 모든 수식을 외울 필요는 없다.

전형적인 자기회귀 LLM의 기본 흐름은 다음과 같다.

text

① 텍스트를 Token으로 나눈다
        ↓
② Token ID를 벡터로 변환한다
        ↓
③ 위치 정보를 반영한다
        ↓
④ Transformer가 문맥을 계산한다
        ↓
⑤ 다음 Token의 Logits를 계산한다

여기에서 학습할 때는 다음 과정이 추가된다.

text

Logits
  ↓
정답 토큰과 비교
  ↓
Cross-Entropy Loss
  ↓
Backpropagation
  ↓
Gradient
  ↓
Optimizer
  ↓
파라미터 업데이트
  ↓
다음 미니배치로 반복

사용할 때는 다음 과정이 이어진다.

text

Logits
  ↓
Greedy 또는 Sampling 등 Decoding
  ↓
다음 Token 선택
  ↓
문맥에 추가
  ↓
다시 Transformer 계산
  ↓
반복

학습과 추론 모두에서 Tokenizer와 Transformer가 사용되지만, 학습에서는 정답을 이용해 파라미터를 업데이트하고, 추론에서는 일반적으로 파라미터를 고정한 채 출력을 생성한다.

35. 마지막으로 핵심만 기억하자

LLM의 Training은

"데이터의 정답 토큰과 모델의 예측을 비교해 손실을 계산하고, 역전파와 Optimizer를 이용해 모델의 파라미터를 반복적으로 조정하는 과정"

이다.

LLM의 Inference는

"학습이 끝난 파라미터를 사용해 입력 문맥에서 다음 토큰의 분포를 계산하고, 디코딩 규칙에 따라 토큰을 하나씩 선택해 출력을 생성하는 과정"

이다.

결국 우리가 ChatGPT와 같은 서비스에 질문하고 답변을 받는 순간 핵심적으로 일어나는 것은 Inference다.

그 순간 모델은 이미 학습 과정에서 조정된 파라미터를 사용한다. 다만 실제 서비스에서는 대화 문맥 구성, 안전 필터, 검색 증강, 도구 호출, 후처리 등이 함께 작동할 수 있다.

LLM을 가장 단순하게 표현하면 다음과 같다.

Training은 모델의 파라미터를 데이터에 맞게 조정하는 일이고, Inference는 그 파라미터로 입력에 대한 출력을 계산하는 일이다.

그리고 두 과정의 중심에는 숫자 계산이 있다.

text

텍스트
  ↓
토큰
  ↓
Token ID
  ↓
벡터
  ↓
Transformer의 행렬 연산
  ↓
Logits
  ↓
확률 분포
  ↓
다음 토큰 선택
  ↓
반복

텍스트를 토큰으로 나누고,
토큰을 ID로 표현하고,
ID를 벡터로 변환하고,
벡터를 여러 층의 행렬 연산으로 변환하고,
그 결과를 Logits와 확률 분포로 바꾸고,
디코딩 규칙에 따라 다음 토큰을 선택한다.

LLM의 지능처럼 보이는 능력은 이러한 대규모 수치 계산이 학습된 파라미터와 Transformer 구조를 통해 수행되는 결과다.

LLM은 어떻게 배우고, 어떻게 대답하는가? - 학습,추론 원리

중년개발자