1.1. 모델의 연산을 이해하기 — Vector & NumPy
지난 편에서는 LLM이 입력된 Text를 처리하고 답변을 생성하기까지의 전체 흐름을 살펴봤다.
Language
↓
Number
↓
Context
↓
Generation그 과정에서 중요한 변환 하나가 있었다.
Token
↓
Embedding
↓
Vector우리가 사용하는 언어가 모델 내부에서는 Vector라는 숫자 표현으로 변환된다.
그런데 여기서 몇 가지 질문이 생긴다.
Vector는 정확히 무엇일까?
왜 하나의 숫자가 아니라 여러 개의 숫자로 표현할까?
Vector와 Vector 사이의 관계는 어떻게 계산할까?
그리고 더 중요한 질문이 있다.
이런 계산이 LLM에서는 실제로 어디에 사용될까?
이번 편에서는 LLM 내부의 모든 수학을 다루지는 않는다.
대신 앞으로 Embedding, Attention, Transformer, RAG를 이해하는 데 계속해서 등장하는 최소한의 개념과 연산을 먼저 살펴본다.
Vector / Matrix / Tensor
↓
NumPy
↓
Vector Operations
↓
┌────────┼─────────┐
↓ ↓ ↓
Dot Cosine Softmax
Product Similarity
↓ ↓ ↓
Attention RAG Attention /
Generation이번 편의 목적은 공식을 많이 외우는 것이 아니다.
LLM 내부에서 숫자가 어떤 형태로 표현되고, 그 숫자들 사이에서 어떤 계산이 이루어지는지 이해하는 것.
그리고 앞으로 다른 기술을 만났을 때
“아, 여기서 이 연산이 다시 사용되는구나.”
라고 연결할 수 있는 기반을 만드는 것이 목표다.
1. Why — LLM은 왜 언어를 숫자로 바꿀까?
우리는 언어를 문자와 단어로 이해한다.
학교
고양이
오늘 날씨가 좋다.하지만 컴퓨터가 실제로 수행하는 것은 결국 수치 연산이다.
따라서 LLM이 언어를 처리하려면 언어를 계산할 수 있는 숫자 형태로 표현해야 한다.
지난 편에서는 그 과정이 다음과 같이 이루어진다는 것을 확인했다.
Text
↓
Tokenization
↓
Token
↓
Token ID
↓
Embedding
↓
Vector여기서 Token ID와 Vector를 구분하는 것이 중요하다.
예를 들어,
"학교" → Token ID 2987이라고 해보자.
2987은 "학교"라는 Token을 찾기 위한 식별 번호다.
2987이라는 숫자 자체에 "학교"의 의미가 들어 있는 것은 아니다.
그래서 모델은 Token을 다시 여러 개의 숫자로 이루어진 표현으로 변환한다.
"학교"
↓
Token ID
↓
Embedding
↓
[0.18, -0.42, 0.71, 0.09, ...]바로 이 표현이 Vector다.
그렇다면 왜 굳이 여러 숫자가 필요할까?
이를 이해하기 위해 Vector부터 시작해보자.
2. Vector — 하나의 대상을 여러 숫자로 표현하기
Vector란?
Vector(벡터)는 여러 개의 숫자가 순서대로 나열된 수학적 객체다.
예를 들어 다음은 세 개의 성분을 가진 Vector다.
[3, 2, 5]하지만 LLM을 공부할 때 Vector를 단순히
여러 숫자를 모아놓은 것
이라고만 이해하면 부족하다.
조금 다른 관점으로 바라보자.
두 개의 숫자가 있다고 해보자.
[3, 2]이를 좌표라고 생각하면 2차원 공간에서 하나의 위치를 나타낼 수 있다.
y
↑
│
2 │ ● (3, 2)
│
│
────────┼──────────────→ x
│ 3숫자가 세 개라면 3차원 공간의 한 위치를 나타낼 수 있다.
[3, 2, 5]그리고 숫자가 수백 개, 수천 개라면?
사람이 직접 그림으로 그릴 수는 없지만 같은 방식으로 고차원 공간의 하나의 표현으로 생각할 수 있다.
[0.18, -0.42, 0.71, 0.09, ..., 0.31]LLM에서는 Token 하나를 이런 고차원의 Vector로 표현할 수 있다.
"학교"
↓
Embedding
↓
[0.18, -0.42, 0.71, 0.09, ...]즉 Vector의 중요한 역할은
하나의 대상을 여러 차원의 숫자를 이용해 표현할 수 있게 하는 것
이다.
Vector의 역할
앞으로 이 시리즈에서는 Vector를 계속 만나게 된다.
Token
↓
Embedding Vector
Query
↓
Query Vector
Key
↓
Key Vector
Document
↓
Embedding Vector대상은 다르지만 공통점은 같다.
모델이 정보를 계산할 수 있도록 여러 숫자로 표현한다.
그래서 Vector는 LLM 내부에서 정보를 표현하고 계산하기 위한 가장 기본적인 형태 중 하나라고 볼 수 있다.
1.3. Matrix — 여러 Vector를 한 번에 다루기
Vector 하나로 Token 하나를 표현할 수 있다고 해보자.
그런데 실제 문장에는 Token이 하나만 존재하지 않는다.
나는 / 오늘 / 학교에 / 갔다각 Token이 다음과 같은 Vector를 가진다고 가정해보자.
나는 → [0.2, 0.7, 0.1]
오늘 → [0.5, 0.3, 0.8]
학교 → [0.9, 0.1, 0.4]
갔다 → [0.4, 0.6, 0.2]이 Vector들을 한곳에 모으면 다음과 같은 형태가 된다.
[
[0.2, 0.7, 0.1],
[0.5, 0.3, 0.8],
[0.9, 0.1, 0.4],
[0.4, 0.6, 0.2]
]이것이 Matrix(행렬)다.
Matrix란?
Matrix는 숫자를 행(Row)과 열(Column) 형태로 배열한 2차원 구조다.
Column
↓ ↓ ↓
[1 2 3] ← Row
[4 5 6] ← Row
[7 8 9] ← RowVector 여러 개를 Matrix로 묶으면 여러 Token의 표현을 한 번에 다룰 수 있다.
Token 1 → Vector ┐
Token 2 → Vector │
Token 3 → Vector ├──→ Matrix
Token 4 → Vector │
Token 5 → Vector ┘Matrix의 역할
Matrix는 단순히 데이터를 정리하기 위한 표가 아니다.
딥러닝에서는 여러 Vector를 한꺼번에 변환하고 계산하는 데 Matrix 연산이 매우 많이 사용된다.
특히 이후 Attention에서 등장하는
Query (Q)
Key (K)
Value (V)역시 실제 계산에서는 여러 Token의 Vector를 모은 Matrix 형태로 다뤄진다.
즉,
Vector
↓
Token 하나의 표현
Matrix
↓
여러 Token의 표현과 연산이라고 생각하면 된다.
1.4. Tensor — 차원이 더 늘어나면?
이제 Tensor라는 용어도 정리해보자.
처음 딥러닝을 공부할 때
Scalar, Vector, Matrix, Tensor
라는 용어가 한꺼번에 등장하면서 어렵게 느껴질 수 있다.
우선 형태만 비교해보면 생각보다 단순하다.
Scalar
3
Vector
[1, 2, 3]
Matrix
[
[1, 2, 3],
[4, 5, 6]
]
Tensor
여러 축을 가진 수치 데이터엄밀한 수학적 정의와 별개로, 딥러닝 프로그래밍에서는 Tensor를 다차원 수치 데이터를 다루는 기본 구조로 접하게 된다.
예를 들어 개념적으로 생각하면,
Token 하나
↓
Vector
Token 여러 개
↓
Matrix
여러 Sequence / Batch
↓
더 높은 차원의 Tensor처럼 데이터의 축이 늘어날 수 있다.
실제 LLM을 구현하거나 사용할 때는 이러한 Tensor 연산을 계속 만나게 된다.
특히 이후 PyTorch를 사용하기 시작하면 torch.Tensor는 거의 모든 모델 연산의 기본 단위가 된다.
지금 단계에서 기억할 것
Scalar → 하나의 값
Vector → 1차원 형태
Matrix → 2차원 형태
Tensor → 다차원 데이터를 다루는 일반적인 구조지금은 이 정도의 구분이면 충분하다.
1.5. NumPy — 숫자를 직접 계산해보자
지금까지 살펴본
Vector
Matrix
Tensor는 숫자를 어떤 형태로 표현하는가에 대한 이야기였다.
이제 실제로 이 숫자들을 계산해보자.
Python에는 수치 연산을 위한 대표적인 라이브러리인 NumPy가 있다.
import numpy as npNumPy를 사용하면 Vector를 다음과 같이 만들 수 있다.
vector = np.array([0.2, 0.5, 0.8])
print(vector)Matrix도 만들 수 있다.
matrix = np.array([
[0.2, 0.5, 0.8],
[0.1, 0.7, 0.3],
[0.9, 0.2, 0.4]
])
print(matrix)그리고 shape을 이용하면 데이터의 형태를 확인할 수 있다.
print(vector.shape)
print(matrix.shape)결과는 다음과 같다.
(3,)
(3, 3)Vector에는 3개의 값이 있고,
Matrix는 3개의 행과 3개의 열을 가지고 있다는 뜻이다.
그런데 왜 NumPy를 사용할까?
Python의 기본 List를 이용해도 숫자를 저장할 수 있다.
하지만 NumPy는 Vector와 Matrix 같은 수치 데이터를 효율적으로 표현하고 연산하기 위한 기능을 제공한다.
예를 들어 두 Vector를 더한다면:
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
print(a + b)결과는
[5 7 9]가 된다.
앞으로 살펴볼 Dot Product나 Vector의 크기 같은 연산도 NumPy를 이용하면 직접 확인할 수 있다.
여기서 한 가지는 구분해둘 필요가 있다.
NumPy 자체가 LLM의 구성 요소인 것은 아니다.
이번 시리즈에서 NumPy를 사용하는 이유는 LLM 내부에서 이루어지는 Vector와 Matrix 연산을 직접 구현하고 확인하기 위해서다.
실제 딥러닝에서는 이후 PyTorch의 Tensor와 연산 기능을 주로 만나게 되지만, 그 전에 NumPy로 계산을 직접 만들어보면 내부에서 무엇이 일어나는지 훨씬 쉽게 이해할 수 있다.
1.6. Dot Product — 두 Vector의 관계를 하나의 값으로 계산하기
Vector를 만들었으니 이제 Vector 사이의 연산을 살펴보자.
두 Vector가 있다고 해보자.
[
A=[1,2,3]
]
[
B=[2,1,3]
]
두 Vector의 Dot Product(내적)는 같은 위치의 값끼리 곱한 뒤 모두 더해서 계산한다.
[
A \cdot B
(1\times2)+(2\times1)+(3\times3)
]
따라서
[
A \cdot B = 13
]
이다.
구조만 보면 다음과 같다.
A = [1, 2, 3]
↓ ↓ ↓
B = [2, 1, 3]
곱한다
[2, 2, 9]
↓
모두 더한다
↓
13즉,
Vector A ──┐
├── Dot Product ──→ Scalar
Vector B ──┘두 Vector를 입력했는데 결과는 하나의 숫자가 나왔다.
Why — 왜 이런 계산이 필요할까?
Vector 두 개가 있을 때 우리는 종종
두 Vector가 서로 어떤 관계를 가지고 있는지
를 하나의 값으로 비교하고 싶다.
Dot Product는 두 Vector의 크기와 방향에 영향을 받으며, 두 Vector가 얼마나 같은 방향으로 정렬되어 있는지와 관련된 정보를 하나의 값으로 나타낼 수 있다.
그리고 이 계산은 이후 LLM의 핵심 기술에서 다시 등장한다.
LLM — Attention
Self-Attention에서는 Query(Q)와 Key(K)의 관계를 계산해야 한다.
이때 사용되는 핵심 연산이 Dot Product다.
Query Vector
│
│
×
│
Key Vector
│
▼
Dot Product
↓
Attention Score실제로 Transformer에서는 이를 기반으로 한 Scaled Dot-Product Attention을 사용한다.
즉 지금 Dot Product를 배우는 이유는 단순히 선형대수 공식을 배우기 위해서가 아니다.
03편에서 Attention이 Token 사이의 관계를 어떻게 계산하는지 이해하기 위해서다.
Code — NumPy로 계산해보기
NumPy에서는 np.dot()을 사용할 수 있다.
import numpy as np
a = np.array([1, 2, 3])
b = np.array([2, 1, 3])
dot_product = np.dot(a, b)
print(dot_product)결과:
13앞에서 직접 계산한 값과 동일하다.
1.7. Cosine Similarity — 두 Vector는 얼마나 비슷할까?
이번에는 조금 다른 문제가 있다.
다음 두 Vector를 생각해보자.
A ───────────────→
B ───────→두 Vector의 길이는 다르지만 방향은 비슷하다.
만약 우리가 Vector의 크기 자체보다
두 Vector가 얼마나 비슷한 방향을 가리키고 있는가?
에 관심이 있다면 어떻게 해야 할까?
여기서 Cosine Similarity(코사인 유사도)가 등장한다.
How — 방향을 비교한다
Cosine Similarity는 두 Vector 사이의 각도를 이용해 방향의 유사성을 측정한다.
[
\text{Cosine Similarity}
\frac{A \cdot B}
{|A||B|}
]
분자를 보면 조금 전 배운 Dot Product가 다시 등장한다.
그리고 분모에는 두 Vector의 크기(Magnitude)가 들어간다.
즉 Dot Product를 Vector의 크기로 정규화함으로써 방향의 유사성을 비교한다.
결과는 일반적으로 다음 범위에 있다.
1 → 같은 방향
0 → 직교
-1 → 반대 방향따라서 값이 1에 가까울수록 두 Vector의 방향이 유사하다고 볼 수 있다.
Code — 직접 계산해보기
import numpy as np
a = np.array([1.0, 2.0, 3.0])
b = np.array([2.0, 1.0, 3.0])
dot_product = np.dot(a, b)
magnitude_a = np.linalg.norm(a)
magnitude_b = np.linalg.norm(b)
cosine_similarity = dot_product / (magnitude_a * magnitude_b)
print(cosine_similarity)여기서
np.linalg.norm(a)은 Vector의 크기를 계산한다.
즉 코드 역시 수식과 동일한 구조다.
Dot Product
↓
두 Vector의 크기로 나눈다
↓
Cosine SimilarityLLM — Embedding과 RAG
그런데 Vector의 방향이 비슷한지를 왜 알아야 할까?
이후 Embedding을 배우면 Text를 Vector로 표현할 수 있게 된다.
Text
↓
Embedding
↓
Vector그렇다면 두 Text의 Vector를 비교할 수도 있다.
Query
↓
Embedding
↓
Query Vector
\
\ Cosine Similarity
/
Document Vector
↑
Embedding
↑
DocumentQuery Vector와 여러 Document Vector의 유사도를 비교하면 Query와 관련성이 높은 문서를 찾는 데 활용할 수 있다.
이 구조는 이후 Vector Search와 RAG를 이해할 때 다시 등장한다.
Query
↓
Embedding
↓
Vector
↓
Similarity Search
↓
관련 Document
↓
LLM즉 Cosine Similarity 역시 지금 한 번 배우고 끝나는 개념이 아니다.
05편에서 RAG가 외부 문서를 어떻게 검색하는지 이해할 때 다시 만나게 된다.
1.8. Softmax — 점수를 비교 가능한 분포로 바꾸기
이번에는 세 후보에 대해 다음과 같은 점수가 나왔다고 해보자.
A 2.1
B 1.2
C 0.3A의 점수가 가장 높다는 것은 알 수 있다.
하지만 이 숫자들은 그대로 확률이라고 할 수 없다.
2.1 + 1.2 + 0.3 ≠ 1또한 모델 내부의 점수는 음수가 될 수도 있고 값의 범위도 일정하지 않을 수 있다.
그렇다면 이 점수들을 상대적으로 비교하기 쉬운 분포로 만들 수 있을까?
여기서 Softmax가 등장한다.
Scores
│
▼
Softmax
│
▼
Probability Distribution예를 들어 설명을 위해 단순화하면 다음과 같은 형태가 된다.
Score Probability
2.1 → 0.64
1.2 → 0.26
0.3 → 0.10
────
1.00Softmax의 출력값들은 0과 1 사이에 있고 전체 합은 1이 된다.
How — 어떻게 계산할까?
Softmax는 각 값에 지수함수 exp를 적용하고, 전체 합으로 나누어 정규화한다.
[
Softmax(x_i)
\frac{e^{x_i}}
{\sum_j e^{x_j}}
]
처음 보면 수식이 복잡해 보일 수 있지만 구조는 단순하다.
Score
↓
exp()
↓
모두 양수로 변환
↓
전체 합으로 나누기
↓
합이 1인 분포Code — 직접 구현해보기
import numpy as np
def softmax(x):
exp_x = np.exp(x)
return exp_x / np.sum(exp_x)
scores = np.array([2.1, 1.2, 0.3])
probabilities = softmax(scores)
print(probabilities)실제 구현에서는 큰 값에서 발생할 수 있는 수치적 문제를 줄이기 위해 보통 다음처럼 최대값을 빼는 방식이 사용된다.
def softmax(x):
exp_x = np.exp(x - np.max(x))
return exp_x / np.sum(exp_x)결과의 의미는 동일하지만 계산이 더 안정적이다.
LLM — Softmax는 어디에서 사용될까?
Softmax는 앞으로 적어도 두 번 중요하게 등장한다.
1. Attention
Attention Scores
↓
Softmax
↓
Attention WeightsToken 사이의 관계를 계산해 얻은 점수를 상대적인 가중치로 변환하는 데 사용된다.
2. Next Token Prediction
Logits
↓
Softmax
↓
Token Probability
↓
Next Token다음 Token 후보들의 Logit을 확률 분포로 변환할 때도 사용된다.
같은 Softmax가 서로 다른 위치에서 다시 등장하는 것이다.
1.9. 지금까지 배운 개념을 연결해보자
이번 편에서는 여러 개념이 등장했다.
하지만 각각을 따로 외울 필요는 없다.
먼저 데이터를 표현하는 구조가 있었다.
Scalar
↓
Vector
↓
Matrix
↓
Tensor그리고 이것들을 Python에서 직접 계산하기 위해 NumPy를 사용했다.
Vector / Matrix
↓
NumPy
↓
수치 연산 직접 구현그다음 Vector 사이에서 필요한 연산을 살펴봤다.
Vector
│
┌────────────┼────────────┐
│ │ │
▼ ▼ ▼
Dot Product Cosine Softmax
│ Similarity │
│ │ ┌─────┴─────┐
▼ ▼ ▼ ▼
Attention Vector Attention Token
Score Search Weight Probability
│ │ │ │
▼ ▼ ▼ ▼
Transformer RAG Transformer Generation처음에는 단순한 수학 개념처럼 보였지만 이제 각각의 역할이 조금씩 연결된다.
| 개념 | 무엇인가? | 핵심 역할 | LLM에서의 연결 |
|---|---|---|---|
| Vector | 여러 숫자로 이루어진 표현 | 하나의 대상을 수치적으로 표현 | Embedding, Hidden Representation |
| Matrix | 숫자의 2차원 배열 | 여러 Vector를 함께 표현·계산 | Transformer의 행렬 연산 |
| Tensor | 다차원 수치 데이터 구조 | Batch 등 복잡한 데이터를 표현 | 딥러닝 모델의 기본 데이터 구조 |
| NumPy | Python 수치 계산 라이브러리 | Vector·Matrix 연산을 직접 구현 | LLM 연산 원리 학습 |
| Dot Product | 두 Vector로 하나의 Scalar를 만드는 연산 | Vector 간 정렬·관계 계산 | Attention Score |
| Cosine Similarity | Vector 방향의 유사도를 측정 | Vector 간 유사성 비교 | Embedding Search, RAG |
| Softmax | 점수를 합이 1인 분포로 변환 | 상대적인 가중치·확률 표현 | Attention Weight, Token Probability |
1.10. Why → How → Code → LLM
이번 편부터 이 시리즈에서 사용할 학습 방식도 본격적으로 시작했다.
예를 들어 Dot Product를 다시 보면 다음과 같다.
WHY
두 Vector의 관계를
하나의 값으로 계산하고 싶다.
↓
HOW
같은 위치의 값을
곱하고 모두 더한다.
↓
CODE
np.dot(a, b)
↓
LLM
Query · Key
↓
Attention ScoreCosine Similarity도 같다.
WHY
두 Vector의 방향이
얼마나 유사한지 알고 싶다.
↓
HOW
Dot Product를
Vector의 크기로 정규화한다.
↓
CODE
dot / (norm_a * norm_b)
↓
LLM
Embedding Similarity
↓
Vector Search
↓
RAGSoftmax 역시 같은 방식으로 연결된다.
WHY
여러 점수를 상대적으로
비교 가능한 분포로 만들고 싶다.
↓
HOW
Exponentiation
+
Normalization
↓
CODE
exp(x) / sum(exp(x))
↓
LLM
Attention Weight
+
Token Probability이것이 이 시리즈에서 기술을 공부하는 방식이다.
단순히
np.dot()사용법을 배운다.
에서 끝나는 것이 아니라,
왜 이 계산이 필요한지 이해하고 → 직접 계산해보고 → LLM 안에서 어디에 사용되는지 다시 확인한다.
앞으로 새로운 기술을 배울 때도 이 흐름을 반복할 것이다.
1.11. 그래서 Vector를 왜 먼저 배웠을까?
이제 처음의 질문으로 돌아가보자.
왜 LLM을 공부하면서 가장 먼저 Vector를 배워야 할까?
앞으로 만나게 될 많은 기술이 결국 Vector와 그 연산 위에서 이루어지기 때문이다.
Vector
│
┌───────────┴───────────┐
│ │
▼ ▼
Embedding Attention
│ │
│ Dot Product
│ │
▼ ▼
Semantic Representation Transformer
│
▼
Cosine Similarity
│
▼
Vector Search
│
▼
RAG그리고 Softmax는 또 다른 경로에서 반복해서 등장한다.
Attention Score
↓
Softmax
↓
Attention Weight그리고
Logits
↓
Softmax
↓
Token Probability
↓
Generation즉 이번 편에서 배운 개념은 독립된 수학 지식이 아니다.
앞으로 배울 기술들의 공통 언어에 가깝다.
1.12. 다음 질문 — 언어는 어떻게 Vector가 될까?
이제 Vector가 무엇인지 알게 되었다.
Vector 여러 개를 Matrix로 표현할 수 있다는 것도 알게 되었고,
Vector 사이에서 Dot Product와 Cosine Similarity 같은 계산을 할 수 있다는 것도 확인했다.
하지만 아직 가장 중요한 과정 하나를 직접 살펴보지 않았다.
"학교"
↓
?
↓
[0.18, -0.42, 0.71, ...]언어가 어떻게 이런 Vector가 되는 걸까?
지난 편에서는 이 ?에 Embedding이라는 이름을 붙였다.
하지만 아직 내부를 열어보지는 않았다.
그리고 그 전에 Text가 어떤 단위로 나뉘는지도 자세히 살펴봐야 한다.
Text
↓
Tokenization
↓
Token
↓
Token ID
↓
Embedding
↓
Vector다음 편에서는 이 과정을 직접 따라가본다.
02. Text에서 Vector까지 — Tokenization & Embedding
Text는 왜 Token으로 나누어야 할까?
하나의 단어는 항상 하나의 Token일까?
BPE와 Subword는 왜 필요할까?
Token ID는 어떻게 Embedding Vector로 변환될까?
그리고 우리가 이번 편에서 배운 Vector가 실제 언어의 표현으로 어떻게 사용되는지 살펴본다.
Vector는 LLM에서 정보를 표현하는 기본적인 언어다.
Matrix와 Tensor는 그 표현을 더 큰 단위로 다룰 수 있게 하고, Dot Product와 Cosine Similarity는 Vector 사이의 관계를 계산한다. Softmax는 계산된 점수를 상대적인 분포로 변환한다.
그리고 이 연산들은 이후
Embedding,Attention,Transformer,RAG,Generation에서 계속해서 다시 등장한다.이번 편에서 숫자를 계산하는 방법을 배웠다면,
다음 편에서는 다시 Language로 돌아가 그 언어가 어떻게 Number가 되는지 살펴본다.
