ML 수학 토대

분류: Layer 11 - AI 기초 & 머신러닝 | 선수지식: 기본 산술, 좌표평면, 함수의 입력·출력 개념, 제곱근·지수·로그의 기초 직관

ML 수학 토대 — 벡터, 확률, gradient

1. 한 줄 정의

ML 수학 토대는 데이터를 숫자 좌표로 표현하는 선형대수, 모델의 불확실한 출력을 다루는 확률, 손실을 줄이는 방향을 찾는 미적분이다.

이 문서는 수학을 잘하는 사람을 위한 압축 노트가 아니다. 벡터, 행렬, 확률, 미분을 처음부터 다시 잡고, 작은 숫자로 손계산해 보면서 “모델 학습이 왜 이런 모양인지”를 이해하는 입구 문서다.

2. 왜 중요한가

LLM이든 이미지 분류 모델이든, 학습과 추론은 크게 세 질문으로 나뉜다.

입력을 어떤 숫자 묶음으로 표현할까? — 벡터와 행렬
모델이 낸 점수를 어떻게 확률처럼 해석할까? — 분포, softmax, cross-entropy
틀린 만큼 어느 방향으로 고칠까? — 미분, gradient(기울기), chain rule

이 세 질문을 모르면 모델은 “큰 검은 상자”처럼 보인다. 반대로 이 세 질문을 잡으면 다음 문제가 훨씬 덜 막힌다.

출력 해석: logit, softmax, cross-entropy, perplexity가 한 흐름으로 보인다.
디버깅: NaN(숫자가 아님), overflow(표현 범위 초과), gradient explosion(기울기 폭발), loss spike가 어떤 수학 신호인지 구분한다.
비용 직관: 차원, 행렬 곱, 시퀀스 길이가 메모리와 연산량에 어떻게 들어가는지 감이 생긴다.
후속 토픽 준비: tokenization, embedding, neural network, transformer, post-training의 수식이 덜 낯설다.

처음 읽을 때는 이 용어들을 완전히 외울 필요가 없다. logit은 확률로 바꾸기 전의 점수, perplexity는 다음 후보를 얼마나 헷갈려 하는지 보는 지표, tokenization은 문장을 모델이 읽을 작은 조각으로 나누는 과정이라고만 잡고 출발하면 된다.

2.5 선행 한계 -> ML 수학 토대가 필요한 이유

규칙 기반 시스템이나 손으로 만든 feature만 다룰 때는 수학을 깊게 몰라도 작은 모델을 운영할 수 있었다. 사람이 “이 단어가 있으면 스팸”, “이 패턴이면 고양이” 같은 규칙과 특징을 직접 만들었기 때문이다.

딥러닝에서는 이 구조가 바뀐다. 모델이 feature를 직접 학습하고, 그 feature는 대부분 벡터와 행렬 안에 들어간다. 출력은 여러 후보 위의 확률 분포가 되고, 학습은 손실 함수의 gradient를 따라 조금씩 가중치를 바꾸는 과정이 된다.

그래서 ML 엔지니어가 보는 많은 현상은 결국 다음 언어로 돌아온다.

데이터와 feature는 벡터 공간의 점이다.
신경망 한 층은 대체로 행렬이 벡터를 바꾸는 함수다.
분류와 다음 토큰 예측은 확률 분포를 맞히는 문제다.
학습은 손실을 줄이는 방향으로 가중치를 옮기는 반복이다.

이 토픽의 목표는 어려운 증명을 외우는 것이 아니다. 후속 문서에서 attention, embedding, optimizer, evaluation을 만났을 때 “아, 이게 어느 수학 도구의 변형인지”를 알아보는 눈을 만드는 것이다.

3. 읽기 전 약속

처음 읽을 때는 모든 수식을 완벽히 외우지 않아도 된다. 아래 기준으로 충분하다.

벡터를 보면 “숫자 여러 개로 만든 좌표”라고 읽는다.
행렬을 보면 “벡터를 다른 벡터로 바꾸는 표”라고 읽는다.
확률 분포를 보면 “가능한 후보마다 확률을 나눠 가진 표”라고 읽는다.
gradient를 보면 “손실이 가장 빨리 커지는 방향”이라고 읽는다.

수식은 이 생각을 짧게 쓰는 표기법이다. 먼저 말로 이해하고, 그다음 작은 숫자로 확인한다.

4. 선형대수 1 — 벡터, 노름, 거리, 내적

4.1 벡터와 차원

**벡터(vector)**는 숫자를 순서대로 묶은 것이다.

[3, 4]
[0.21, -0.18, 0.55]

첫 번째 벡터는 숫자가 2개라서 2차원 벡터다. 두 번째 벡터는 숫자가 3개라서 3차원 벡터다. ML에서 차원(dimension)은 “표현에 쓰는 숫자 칸의 개수”라고 보면 된다.

2차원 벡터 [3, 4]는 좌표평면에서 오른쪽으로 3, 위로 4 간 점을 뜻할 수 있다. 임베딩에서는 같은 원리로 단어, 문장, 이미지, 사용자를 수백~수천 개 숫자로 표현한다.

"고양이" -> [0.21, -0.18, 0.55, ...]
"강아지" -> [0.19, -0.20, 0.58, ...]
"비행기" -> [-0.42, 0.71, 0.03, ...]

숫자 하나하나가 사람이 붙인 “귀여움”, “탈것” 같은 이름을 갖는다고 생각하면 오해가 생긴다. 임베딩 차원은 보통 사람이 직접 해석하기 어렵다. 대신 비슷한 의미의 객체가 가까운 위치에 오도록 학습된 좌표계라고 보는 편이 안전하다.

4.2 노름 — 벡터의 크기

**노름(norm)**은 벡터의 크기를 재는 규칙이다. 가장 자주 보는 것은 L1 norm과 L2 norm이다.

벡터 a = [3, 4]

L1 norm = |3| + |4| = 7
L2 norm = sqrt(3^2 + 4^2) = sqrt(9 + 16) = 5

L2 norm은 좌표평면에서 원점 [0, 0]부터 [3, 4]까지의 직선거리다. 그래서 유클리드 거리와 자연스럽게 이어진다.

4.3 거리 — 두 벡터가 얼마나 떨어졌는가

두 벡터 사이의 유클리드 거리는 두 벡터를 뺀 뒤 L2 norm을 계산한다.

a = [1, 2]
b = [4, 6]

b - a = [3, 4]
distance(a, b) = sqrt(3^2 + 4^2) = 5

거리 기준은 “위치가 가까운가”를 본다. 임베딩 검색에서는 질문 벡터와 문서 벡터가 가까우면 관련 문서일 가능성이 높다고 본다.

하지만 거리만 보면 벡터의 크기도 같이 영향을 준다. 문장 길이, 모델 내부 스케일, 정규화 방식 때문에 크기가 달라질 수 있다. 그래서 임베딩 검색에서는 방향을 보는 코사인 유사도도 자주 쓴다.

4.4 내적 — 같은 방향을 얼마나 보는가

**내적(dot product)**은 같은 위치의 숫자를 곱해 더한 값이다.

a = [1, 2]
b = [3, 4]

a · b = 1*3 + 2*4 = 11

내적에는 두 의미가 있다.

계산 의미: 같은 자리 곱의 합이다.
기하 의미: 두 벡터가 얼마나 같은 방향을 보는지 나타낸다.

작은 예시를 보자.

[1, 0] · [0, 1] = 1*0 + 0*1 = 0
[1, 0] · [1, 0] = 1*1 + 0*0 = 1
[1, 0] · [-1, 0] = 1*(-1) + 0*0 = -1

내적이 0이면 두 방향이 서로 직각이다. 양수면 어느 정도 같은 방향이고, 음수면 반대 방향 성분이 있다.

4.5 코사인 유사도 — 방향만 비교하기

**코사인 유사도(cosine similarity)**는 내적을 두 벡터 크기의 곱으로 나눠서, 크기 영향을 줄이고 방향만 비교한다.

cos(a, b) = (a · b) / (||a|| * ||b||)
범위: -1 ~ 1
1: 같은 방향, 0: 직각, -1: 반대 방향

손계산 예시:

a = [3, 4]
b = [6, 8]

a · b = 3*6 + 4*8 = 50
||a|| = 5
||b|| = 10
cos(a, b) = 50 / (5*10) = 1

b는 a를 2배 늘린 벡터라 방향이 완전히 같다. 그래서 코사인 유사도는 1이다.

반례도 중요하다.

a = [3, 4]
c = [-4, 3]

a · c = 3*(-4) + 4*3 = 0
cos(a, c) = 0 / (5*5) = 0

두 벡터 모두 길이는 5지만 방향은 직각이다. “길이가 같으면 비슷하다”는 직관은 틀릴 수 있다. 임베딩에서도 크기와 방향을 구분해야 한다.

4.6 차원의 비용 감각

차원이 커지면 표현할 공간은 넓어진다. 대신 저장 공간과 계산 비용도 거의 비례해서 늘어난다.

저장 공간 대략 = 벡터 개수 * 차원 수 * 숫자 1개의 바이트

예를 들어 1,000,000개 문서를 768차원 fp32(숫자 1개 4바이트)로 저장하면:

1,000,000 * 768 * 4 bytes
= 3,072,000,000 bytes
≈ 3.07 GB

1536차원으로 늘리면 약 6.14GB가 된다. 이 숫자에는 인덱스 메타데이터나 DB 오버헤드는 빠져 있다. 그래도 “차원 2배 -> 벡터 원본 저장량 2배”라는 기본 감각은 맞다.

선택 기준:

상황	먼저 볼 것
검색 품질이 낮다	차원보다 데이터 품질, 문서 나누기(chunking), 모델 적합성을 먼저 의심한다
저장 비용이 크다	차원 축소, 숫자 압축(quantization), 중복 문서 제거를 비교한다
모든 문서가 비슷하게 검색된다	코사인 분포가 한쪽으로 몰리는지 확인한다
query와 문서 길이가 크게 다르다	거리보다 코사인 유사도가 더 안정적일 수 있다

5. 선형대수 2 — 행렬과 선형 변환

5.1 행렬은 벡터를 바꾸는 표다

**행렬(matrix)**은 숫자를 행(row)과 열(column)로 놓은 표다.

W = [
  [1, 2, 0],
  [0, 1, 3],
]

이 행렬은 2행 3열이므로 모양을 2 x 3이라고 쓴다. 3차원 벡터를 넣으면 2차원 벡터를 만든다.

x = [2, 1, 3]

y = W x

행렬 곱을 손으로 계산하면 각 행과 입력 벡터의 내적이다.

y_1 = 1*2 + 2*1 + 0*3 = 4
y_2 = 0*2 + 1*1 + 3*3 = 10

y = [4, 10]

신경망 한 층에서 자주 보는 식도 같은 구조다.

y = W x + b

x: 입력 벡터
W: 가중치 행렬
b: bias, 출력에 더하는 보정값
y: 출력 벡터

여기서 W는 “입력 좌표를 어떤 출력 좌표로 바꿀지”를 담고, b는 전체 위치를 조금 옮긴다.

5.2 행렬 곱이 가능한 조건

행렬 곱은 아무 모양끼리나 할 수 없다. 가운데 차원이 맞아야 한다.

(m x n) 행렬 * (n x k) 행렬 = (m x k) 행렬

예시:

W: 2 x 3
x: 3 x 1
W x: 2 x 1

W의 열 수 3과 x의 행 수 3이 같아서 곱할 수 있다. 결과는 W의 행 수 2와 x의 열 수 1을 따라 2 x 1이 된다.

shape 오류를 만났을 때는 먼저 이 규칙을 본다. “숫자가 이상하다”보다 “곱하려는 두 텐서의 가운데 차원이 맞는가”가 첫 질문이다.

5.3 선형 변환의 의미와 경계

행렬은 **선형 변환(linear transform)**을 표현한다. 선형이라는 말은 두 성질을 뜻한다.

W(a + b) = W a + W b
W(ca) = c W a

말로 풀면 “입력을 더한 뒤 변환하든, 변환한 뒤 더하든 결과가 같다”와 “입력을 2배 하면 출력도 2배 된다”는 뜻이다.

이 성질은 계산을 빠르고 예측 가능하게 만든다. 하지만 선형 변환만 여러 번 쌓으면 결국 하나의 선형 변환과 크게 다르지 않다. 그래서 신경망에는 ReLU, GELU 같은 비선형 함수가 중간에 들어간다. ReLU와 GELU는 직선을 한 번 꺾거나 부드럽게 눌러, 모델이 직선 경계만이 아니라 휘어진 패턴도 배울 수 있게 하는 함수라고 보면 된다. 이 문서에서는 비선형 함수의 상세보다, W x + b가 한 층의 기본 뼈대라는 점을 잡으면 충분하다.

5.4 Transpose와 inverse

**Transpose(전치)**는 행과 열을 바꾸는 연산이다.

W = [
  [1, 2, 0],
  [0, 1, 3],
]

W^T = [
  [1, 0],
  [2, 1],
  [0, 3],
]

전치는 shape를 맞추거나, 모든 쌍의 내적을 한 번에 계산할 때 자주 등장한다. 예를 들어 attention의 Q K^T는 query 행렬과 key 행렬의 모든 내적 표를 만드는 식이다. 처음 읽을 때는 “전치해서 안쪽 차원을 맞춘다” 정도로 이해하면 된다.

**역행렬(inverse matrix)**은 행렬의 되돌리기 연산이다.

W W^(-1) = I

하지만 모든 행렬에 역행렬이 있는 것은 아니다.

정방행렬이어야 한다. 즉 n x n 모양이어야 한다.
행이나 열이 서로 독립적이어야 한다. 한 행이 다른 행의 배수면 정보를 잃는다.
직사각형 가중치 행렬은 애초에 역행렬 대상이 아니다.

ML에서는 역행렬을 직접 구해 정답을 한 번에 찾는 방식이 드물다. 가중치 행렬은 정방이 아닐 때가 많고, 큰 역행렬 계산은 비싸며, 비선형 함수와 손실이 끼어 있기 때문이다. 그래서 보통 gradient 기반 학습으로 조금씩 고친다.

5.5 SVD — 행렬을 중요한 방향으로 분해한다

SVD(Singular Value Decomposition, 특이값 분해)는 행렬을 “중요한 방향과 그 세기”로 나누어 보는 도구다. 처음에는 공식을 외울 필요가 없다. PCA 같은 차원 축소에서 “데이터가 가장 많이 퍼진 방향을 찾는다”고 말할 때, 그 계산 뒤쪽에 SVD가 자주 있다.

예를 들어 사용자-상품 점수 표가 있다고 하자. SVD는 이 표를 몇 개의 큰 패턴으로 압축해 “액션 영화를 좋아하는 방향”, “가벼운 코미디를 좋아하는 방향”처럼 중요한 축을 뽑아내는 데 쓰일 수 있다. 자세한 계산은 선형대수 심화지만, L11-20의 PCA를 읽을 때는 “행렬에서 중요한 방향을 뽑는 도구” 정도로 잡으면 충분하다.

6. 확률 — 분포, 조건부 확률, softmax

6.1 확률과 분포

**확률(probability)**은 어떤 일이 일어날 가능성을 0과 1 사이 숫자로 나타낸 것이다. 0은 불가능, 1은 확실함이다.

**확률 분포(distribution)**는 가능한 모든 결과에 확률을 나눠 준 표다.

다음 토큰 후보:

"밥"  : 0.50
"물"  : 0.30
"잠"  : 0.20
합계  : 1.00

분류 모델이 “고양이 80%, 강아지 15%, 그 외 5%“라고 말할 때도 분포다. LLM이 다음 토큰을 예측할 때도 어휘 전체에 대한 분포를 만든다.

자주 만나는 분포:

분포	의미	ML에서 보는 곳
Bernoulli	성공/실패처럼 결과가 2개	클릭 여부, 정답/오답
Categorical	여러 후보 중 하나	분류, 다음 토큰 예측
Normal(Gaussian)	평균 주변에 종 모양으로 퍼짐	노이즈, 초기화 직관
Uniform	모든 후보가 같은 확률	무작위 선택, 기준선

6.2 기댓값과 분산

**기댓값(expectation)**은 분포의 평균 위치다. 각 값에 그 값이 나올 확률을 곱해 더한다.

X가 0일 확률: 0.7
X가 10일 확률: 0.3

E[X] = 0*0.7 + 10*0.3 = 3

여기서 기댓값 3은 실제로 나올 수 있는 값이 아닐 수도 있다. X는 0 또는 10만 나온다. 기댓값은 “많이 반복했을 때 평균적으로 어디쯤인가”를 말한다.

**분산(variance)**은 값이 평균에서 얼마나 퍼져 있는지다.

Var[X] = E[(X - E[X])^2]

위 예시에서 E[X] = 3
값 0의 기여: (0 - 3)^2 * 0.7 = 9 * 0.7 = 6.3
값 10의 기여: (10 - 3)^2 * 0.3 = 49 * 0.3 = 14.7
Var[X] = 21

표준편차는 분산의 제곱근이다. sqrt(21) ≈ 4.58이다. 분산은 제곱 단위라 크기가 직관적이지 않을 수 있고, 표준편차는 원래 값과 같은 단위라 해석하기 쉽다.

ML에서 이 감각은 학습 안정성과 연결된다. batch 안의 값이나 gradient가 너무 넓게 퍼지면 업데이트가 흔들릴 수 있다.

6.3 조건부 확률 — 문맥이 있을 때의 확률

**조건부 확률(conditional probability)**은 어떤 조건이 주어졌을 때의 확률이다.

P(비가 온다 | 하늘이 흐리다)

왼쪽은 알고 싶은 사건이고, 오른쪽은 이미 주어진 조건이다. LLM의 다음 토큰 예측도 같은 모양이다.

P(다음 토큰 | 지금까지의 컨텍스트)

“나는 아침에” 다음에는 “밥”의 확률이 높을 수 있고, “비행기는 활주로에서” 다음에는 “이륙”의 확률이 높을 수 있다. 조건이 바뀌면 분포도 바뀐다.

6.4 Logit과 softmax

모델은 처음부터 확률을 직접 내지 않는 경우가 많다. 대신 각 후보에 점수(score)를 준다. 이 점수를 ML에서는 자주 logit이라고 부른다.

logits = [2, 1, 0]

logit은 아무 실수나 될 수 있다. 음수도 가능하고, 합이 1일 필요도 없다. 그래서 logit을 확률 분포로 바꾸는 함수가 필요하다. 그 대표가 softmax다.

softmax(z_i) = exp(z_i) / sum_j exp(z_j)

손계산을 해 보자.

z = [2, 1, 0]

exp(2) ≈ 7.39
exp(1) ≈ 2.72
exp(0) = 1
합계 ≈ 11.11

softmax(z) ≈ [7.39/11.11, 2.72/11.11, 1/11.11]
           ≈ [0.665, 0.245, 0.090]

softmax 결과는 모두 양수이고 합이 1이다. 그래서 확률 분포처럼 해석할 수 있다.

temperature는 softmax 전에 logit을 나누는 값이다.

softmax(z / T)

T가 작다: 큰 logit이 더 두드러져 분포가 뾰족해진다.
T가 크다: logit 차이가 줄어 분포가 평평해진다.

예를 들어 z = [2, 1, 0]을 T=2로 나누면 [1, 0.5, 0]이 되어 차이가 작아진다. 그 결과 가장 큰 후보의 확률이 내려가고, 다른 후보의 확률이 올라간다.

6.5 Log-Sum-Exp — overflow를 피하는 같은 계산

softmax에는 실전에서 중요한 함정이 있다. exp(z)는 지수 함수로, 입력이 1 커질 때마다 같은 양을 더하는 것이 아니라 곱셈처럼 빠르게 커진다. log(x)는 그 반대로 큰 곱셈 규모를 더 작은 덧셈 규모로 읽게 해주는 함수다. exp(z)는 z가 커지면 매우 빨리 커진다. 컴퓨터 숫자 범위를 넘으면 overflow가 나고, 그 뒤 계산이 inf나 NaN으로 망가질 수 있다.

예를 들어 다음 두 logit은 차이만 보면 작다.

z = [1000, 999]

naive softmax는 exp(1000)을 먼저 계산하려다 overflow가 난다. 하지만 softmax는 모든 logit에서 같은 값을 빼도 결과가 바뀌지 않는다. 그래서 최댓값 1000을 뺀다.

z - max(z) = [0, -1]

exp(0) = 1
exp(-1) ≈ 0.368
합계 ≈ 1.368

softmax ≈ [1/1.368, 0.368/1.368]
        ≈ [0.731, 0.269]

이 생각이 log-sum-exp trick이다. 수학적으로 같은 값을 더 안전하게 계산한다.

실패 신호:

loss가 갑자기 NaN이 된다.
logit 최댓값이 계속 커지고 softmax가 거의 [1, 0, 0, ...]처럼 굳는다.
직접 구현한 softmax와 log 조합에서 overflow/underflow가 난다.

처음 대응 기준은 긴 런북이 아니라 간단하다. 직접 exp와 log를 이어 붙이기보다 프레임워크의 안정화된 cross_entropy나 log_softmax를 사용한다.

6.6 Cross-Entropy — 정답에 낮은 확률을 주면 크게 벌점

Cross-entropy는 정답 분포 p와 모델 예측 분포 q가 얼마나 다른지 재는 손실이다.

H(p, q) = -sum_i p_i * log(q_i)

분류에서는 정답이 보통 one-hot이다.

정답: class 0
p = [1, 0, 0]

이때 cross-entropy는 정답 class에 모델이 준 확률만 보면 된다.

q = [0.8, 0.1, 0.1]
loss = -log(0.8) ≈ 0.223

q = [0.1, 0.8, 0.1]
loss = -log(0.1) ≈ 2.303

정답에 80%를 주면 손실이 작고, 정답에 10%만 주면 손실이 크다. 이 단순한 원리 때문에 cross-entropy는 분류와 next-token prediction에서 기본 손실로 쓰인다.

6.7 Perplexity — 평균적으로 몇 개 후보 사이에서 헷갈리는가

**Perplexity(PPL)**는 평균 cross-entropy를 지수로 바꾼 값이다.

PPL = exp(평균 cross-entropy)

작은 예시:

평균 cross-entropy = 0
PPL = exp(0) = 1

평균 cross-entropy ≈ 0.693
PPL ≈ exp(0.693) ≈ 2

평균 cross-entropy ≈ 2.303
PPL ≈ exp(2.303) ≈ 10

PPL=2라면 아주 거칠게 “평균적으로 2개 후보 사이에서 헷갈리는 수준”이라고 볼 수 있다. PPL이 낮을수록 다음 토큰에 높은 확률을 줬다는 뜻이다. 단, 토크나이저와 데이터셋이 다르면 PPL을 직접 비교하기 어렵다.

7. 미적분 — derivative, gradient, learning rate

7.1 미분은 변화율이다

**미분(derivative)**은 입력을 아주 조금 바꿨을 때 출력이 얼마나 바뀌는지 재는 값이다.

df/dx = lim_{h -> 0} [f(x+h) - f(x)] / h

처음에는 극한 표기보다 “기울기”라고 생각하면 된다. 예를 들어:

f(w) = (w - 3)^2

이 함수는 w가 3일 때 0이고, 3에서 멀어질수록 커진다. 미분하면:

df/dw = 2(w - 3)

w=1에서:

df/dw = 2(1 - 3) = -4

미분값이 -4라는 말은 w를 조금 키우면 f가 줄어드는 방향이라는 뜻이다. 그래서 손실을 줄이려면 w를 키우는 쪽으로 움직이면 된다.

7.2 Learning rate와 gradient descent

ML에서 f는 보통 손실 함수 L이고, w는 가중치다. Gradient descent는 미분값의 반대 방향으로 가중치를 옮긴다.

w_new = w_old - η * dL/dw

η: learning rate, 한 번에 얼마나 움직일지 정하는 값

방금 예시에서 w=1, dL/dw=-4, learning rate η=0.1이면:

w_new = 1 - 0.1*(-4)
      = 1 + 0.4
      = 1.4

w가 1에서 1.4로 움직였다. 정답 위치 3에 가까워졌으므로 손실이 줄어든다.

learning rate의 경계:

상황	의미
η가 너무 크다	최저점을 지나쳐 loss가 튀거나 발산한다
η가 너무 작다	loss는 줄지만 너무 느리다
초반 loss가 자주 spike	learning rate, 초기 완만 증가 구간(warmup), gradient norm을 먼저 본다
loss가 거의 안 움직임	learning rate가 너무 작거나 gradient가 사라졌을 수 있다

여기서 중요한 것은 “항상 더 큰 learning rate가 빠르다”가 아니라 “한 번에 움직이는 폭이 손실 지형에 맞아야 한다”는 점이다.

7.3 부분 미분과 gradient

모델 가중치는 하나가 아니라 아주 많다. 변수가 여러 개일 때 한 변수만 바꿔 보는 미분을 **부분 미분(partial derivative)**이라고 한다.

L(w1, w2) = (w1 - 2)^2 + (w2 + 1)^2

부분 미분:

∂L/∂w1 = 2(w1 - 2)
∂L/∂w2 = 2(w2 + 1)

w1=0, w2=1이면:

∂L/∂w1 = 2(0 - 2) = -4
∂L/∂w2 = 2(1 + 1) = 4

모든 부분 미분을 모은 벡터가 gradient다.

∇L = [-4, 4]

gradient는 손실이 가장 빨리 커지는 방향이다. 학습은 그 반대 방향으로 간다.

w_new = w_old - η * ∇L

η=0.1이면:

[w1, w2] = [0, 1]
∇L = [-4, 4]

new = [0, 1] - 0.1*[-4, 4]
    = [0.4, 0.6]

w1은 정답 2 쪽으로 커지고, w2는 정답 -1 쪽으로 작아졌다.

7.4 Chain rule — 여러 함수가 이어질 때의 미분

신경망은 함수가 여러 층으로 이어진 구조다.

x -> layer1 -> layer2 -> loss

**Chain rule(체인룰)**은 함수 합성의 미분 공식이다.

f(g(x))의 미분 = f'(g(x)) * g'(x)

손계산 예시:

a = 2x
L = a^2

x가 L에 미치는 영향을 직접 보면 L = (2x)^2 = 4x^2이고, 미분은 8x다.

체인룰로 보면:

dL/da = 2a
da/dx = 2
dL/dx = dL/da * da/dx = 2a * 2 = 4a

x=3이면 a=6이므로:

dL/dx = 4*6 = 24

직접 미분한 8x에 x=3을 넣어도 24다. Backpropagation은 이 체인룰을 출력에서 입력 방향으로 반복 적용하는 계산이다.

7.5 Jacobian — 벡터 함수의 부분 미분 표

입력도 여러 개, 출력도 여러 개인 함수가 있다.

f(x, y) = [
  x + y,
  x * y,
]

이 함수는 2차원 입력을 받아 2차원 출력을 낸다. 각 출력이 각 입력에 대해 얼마나 변하는지 표로 정리한 것이 **Jacobian(야코비안)**이다.

J = [
  [∂f1/∂x, ∂f1/∂y],
  [∂f2/∂x, ∂f2/∂y],
]

위 함수에서는:

f1 = x + y  -> ∂f1/∂x = 1, ∂f1/∂y = 1
f2 = x*y    -> ∂f2/∂x = y, ∂f2/∂y = x

J = [
  [1, 1],
  [y, x],
]

x=2, y=3이면:

J = [
  [1, 1],
  [3, 2],
]

실전에서는 PyTorch 같은 자동 미분이 Jacobian 전체를 직접 만들지 않고 필요한 곱만 효율적으로 계산한다. 그래도 Jacobian의 의미를 알면 “벡터 출력이 벡터 입력에 어떻게 민감한가”를 말로 설명할 수 있다.

7.6 Gradient 실패 신호

Gradient는 학습의 방향 신호다. 이 신호가 너무 작거나 너무 크면 학습이 깨진다.

실패 신호	수학적 의미	먼저 의심할 것
gradient norm이 계속 0에 가까움	변화 방향이 사라짐	활성화 함수(activation), 가중치 초기화(initialization), 포화(saturation)
gradient norm이 갑자기 매우 큼	작은 업데이트가 큰 이동이 됨	learning rate, exploding gradient, clipping
loss가 `NaN`	숫자 계산이 깨짐	overflow, division by zero, unstable softmax
loss가 위아래로 크게 튐	업데이트 폭이 지형보다 큼	learning rate, batch variance
train loss만 내려가고 val loss는 나빠짐	훈련 데이터에 과적합	규제(regularization), 데이터 분리(data split)

처음 읽을 때는 각 처방을 외우기보다, “gradient는 방향과 크기를 가진 신호이고, 신호가 사라지거나 폭발하면 학습도 깨진다”를 기억하면 된다.

8. 세 갈래를 하나로 묶는 작은 분류기

이제 선형대수, 확률, 미적분이 한 번에 만나는 예시를 보자.

입력 벡터:

x = [2, 1]

가중치 행렬:

W = [
  [1, 0],
  [0, 1],
]

행렬 곱으로 logit을 만든다.

z = W x = [2, 1]

softmax로 확률을 만든다.

softmax([2, 1]) ≈ [0.731, 0.269]

정답이 class 1이라고 하자.

p = [0, 1]
q = [0.731, 0.269]
loss = -log(0.269) ≈ 1.31

softmax + cross-entropy의 gradient는 간단하게 q - p가 된다.

dL/dz = q - p
      = [0.731, 0.269] - [0, 1]
      = [0.731, -0.731]

해석:

class 0 logit은 너무 높다. 줄여야 한다.
class 1 logit은 너무 낮다. 올려야 한다.

이 한 예시에 세 갈래가 모두 들어 있다.

행렬 곱 W x로 입력을 logit으로 바꿨다.
softmax로 logit을 확률 분포로 바꿨다.
cross-entropy와 gradient로 어느 방향으로 고칠지 알았다.

후속 문서의 신경망, backprop, transformer도 크고 복잡해졌을 뿐 이 흐름을 반복한다.

9. 새 ML 기법을 만났을 때의 4질문

새 알고리즘이나 LLM 기법을 볼 때는 아래 네 질문을 던진다.

어떤 벡터·행렬 공간에서 작동하는가? 입력 차원, hidden dimension, 출력 모양은 무엇인가?
어떤 확률 분포나 손실을 쓰는가? categorical, Gaussian, cross-entropy, 평균제곱오차(MSE) 중 무엇인가?
gradient가 어디로 흐르는가? chain rule 경로에서 사라지거나 폭발할 곳은 어디인가?
어떤 행렬 곱이 비용을 결정하는가? 차원이나 시퀀스 길이가 커질 때 어느 부분이 커지는가?

Attention을 아주 얕게만 적용하면:

질문	Attention에서의 답
공간	query, key, value 벡터 공간
분포/손실	`Q K^T` 점수를 softmax로 정규화해 attention weight를 만든다
gradient	softmax가 너무 뾰족해지면 gradient가 약해질 수 있다
비용	모든 query-key 쌍을 비교하므로 시퀀스 길이에 민감하다

비용 감각은 n x n 표로 보면 쉽다. 토큰이 4개면 query-key 비교가 16칸이고, 8개면 64칸이다. 시퀀스 길이가 2배가 되면 비교 칸은 4배가 된다. 이 n^2 감각이 long-context 문서에서 다시 등장한다.

여기서 attention 수식을 완전히 이해할 필요는 없다. 지금은 “내적 표 -> softmax -> 가중합”이라는 큰 흐름만 잡고, 자세한 내용은 트랜스포머 문서에서 다시 다룬다.

10. 실무에서 어디에 쓰이나

임베딩 검색: 문서와 질문을 벡터로 바꾸고, 코사인 유사도나 거리로 가까운 문서를 찾는다.
분류 모델: logit을 softmax로 확률화하고, cross-entropy로 틀린 정도를 잰다.
LLM 다음 토큰 예측: 지금까지의 컨텍스트를 조건으로 다음 토큰 분포를 만든다.
신경망 학습: gradient descent와 chain rule로 가중치를 업데이트한다.
정규화와 안정화: 평균, 분산, gradient 크기를 관리해 학습을 덜 흔들리게 한다.
비용 추정: 차원과 행렬 곱 크기로 메모리와 연산량의 1차 감을 잡는다.

운영에서 필요한 수학은 “증명 전체”보다 “수치가 커지면 어디가 커지는가”에 가깝다. 예를 들어 임베딩 차원은 저장량에 거의 비례하고, 행렬 곱의 shape는 연산량을 결정하며, softmax overflow는 NaN으로 관측된다. 같은 원리로 sequence length, hidden dimension, attention head 수를 잘못 읽으면 메모리 견적이 한 자릿수 이상 틀릴 수 있다. sequence length는 한 번에 보는 토큰 수, hidden dimension은 토큰 하나를 담는 벡터 칸 수, attention head는 여러 관점의 attention을 병렬로 나눈 묶음이다. 처음에는 정확한 GPU 공식보다 “shape가 곧 비용의 첫 근사”라는 감각을 잡으면 된다.

11. 자주 헷갈리는 개념 비교

개념 A	개념 B	차이점
L1 norm	L2 norm	L1은 절댓값 합, L2는 제곱합의 제곱근
거리	코사인 유사도	거리는 위치 차이, 코사인은 방향 유사도
내적	행렬 곱	내적은 두 벡터 -> 스칼라, 행렬 곱은 여러 내적을 묶은 변환
차원	벡터 개수	차원은 벡터 하나의 숫자 칸 수, 벡터 개수는 데이터 수
logit	probability	logit은 임의 실수 점수, probability는 0~1이고 합이 1
expectation	variance	기댓값은 평균 위치, 분산은 퍼진 정도
derivative	partial derivative	derivative는 1변수 변화율, partial derivative는 여러 변수 중 하나의 변화율
gradient	Jacobian	gradient는 스칼라 손실에 대한 부분 미분 벡터, Jacobian은 벡터 함수의 부분 미분 행렬
learning rate	gradient	learning rate는 이동 크기 배율, gradient는 이동 방향 신호
cross-entropy	perplexity	cross-entropy는 손실, perplexity는 그 손실을 후보 수 감각으로 바꾼 값

12. 실패 신호를 수학 언어로 읽기

관측	수학 언어로 번역	첫 확인
검색 결과가 전부 비슷하다	벡터 방향이 잘 분리되지 않거나 유사도 분포가 몰림	임베딩 모델, 문서 나누기(chunking), 정규화
행렬 곱 shape 오류	안쪽 차원이 맞지 않음	`(m x n) * (n x k)` 규칙
softmax 결과가 거의 one-hot	logit 차이가 너무 커져 포화(saturation)	temperature, scaling, 안정화
loss가 NaN	overflow/underflow 또는 잘못된 연산	log-sum-exp, 0으로 나누기, 숫자 저장 형식(dtype)
gradient norm이 폭발	업데이트 방향 신호가 과도하게 큼	learning rate, gradient clipping, 가중치 초기화
loss가 안 내려감	gradient가 너무 작거나 업데이트가 부적절	learning rate, 포화(saturation), 데이터/라벨

이 표는 응급 복구 절차가 아니다. 처음에는 “어떤 수학 개념이 깨졌는가”를 빠르게 좁히는 지도처럼 쓰면 된다.

13. 직접 손으로 확인해볼 것

13.1 벡터와 유사도

[3, 4]의 L1 norm과 L2 norm을 계산한다.
[1, 2]와 [4, 6]의 유클리드 거리를 계산한다.
[3, 4]와 [6, 8]의 코사인 유사도가 1이 되는지 확인한다.
[3, 4]와 [-4, 3]의 내적이 0이 되는지 확인한다.

13.2 행렬 곱

다음을 손으로 계산한다.

W = [
  [1, 2, 0],
  [0, 1, 3],
]
x = [2, 1, 3]

예상 결과는 [4, 10]이다. 결과가 다르면 각 행과 x의 내적을 다시 확인한다.

13.3 Softmax와 cross-entropy

z = [2, 1, 0]에 대해:

exp(2), exp(1), exp(0)을 대략 계산한다.
softmax 결과가 [0.665, 0.245, 0.090] 근처인지 확인한다.
정답이 첫 번째 class일 때 cross-entropy가 -log(0.665)인지 확인한다.
정답 확률이 0.1로 내려가면 손실이 왜 커지는지 설명한다.

13.4 Gradient descent

L(w) = (w - 3)^2, w=1, η=0.1에서:

dL/dw = 2(w - 3)을 계산한다.
w가 1에서 1.4로 이동하는지 확인한다.
η=2.0이면 한 번에 너무 멀리 움직일 수 있음을 숫자로 확인한다.

13.5 Jacobian

f(x, y) = [x + y, x*y]에서:

Jacobian의 네 칸을 채운다.
x=2, y=3일 때 [[1, 1], [3, 2]]가 되는지 확인한다.

14. 체크리스트

ML 수학 토대 체크

벡터가 숫자 좌표이고, 차원이 숫자 칸의 개수임을 설명할 수 있다
L1 norm, L2 norm, 거리, 코사인 유사도를 작은 숫자로 계산할 수 있다
내적이 같은 자리 곱의 합이며 방향 유사도와 연결됨을 설명할 수 있다
행렬 곱 `W x + b`가 신경망 한 층의 기본 뼈대임을 설명할 수 있다
전치와 역행렬의 의미, 그리고 역행렬이 항상 존재하지 않는 이유를 말할 수 있다
확률 분포, 기댓값, 분산, 조건부 확률을 작은 예시로 설명할 수 있다
logit을 softmax로 확률 분포로 바꾸고, log-sum-exp가 overflow를 막는 이유를 설명할 수 있다
cross-entropy와 perplexity가 무엇을 재는지 설명할 수 있다
derivative, partial derivative, gradient, learning rate의 관계를 설명할 수 있다
chain rule이 backprop의 수학적 토대임을 작은 합성 함수로 확인할 수 있다
Jacobian이 벡터 함수의 부분 미분 표임을 설명할 수 있다
NaN, overflow, gradient explosion 같은 실패 신호를 수학 개념과 연결할 수 있다

15. 추가 학습 키워드

선형대수: basis, rank, eigenvalue/eigenvector, SVD, tensor
확률: Bayes rule, entropy, KL divergence, maximum likelihood estimation
미적분/최적화: Hessian, convex/non-convex, momentum, Adam/AdamW
ML 안정화: gradient clipping, learning rate schedule, normalization, mixed precision

처음에는 이 키워드를 모두 공부하지 않아도 된다. 이 문서의 손계산이 편해진 뒤, 후속 L11 문서에서 필요할 때 하나씩 붙이면 된다.

16. 5줄 요약

벡터는 데이터를 숫자 좌표로 표현하고, norm·거리·내적은 벡터 관계를 재는 도구다.
행렬은 벡터를 다른 벡터로 바꾸는 표이며, 신경망 한 층은 대체로 W x + b로 시작한다.
확률은 모델 출력의 언어이고, softmax는 logit을 분포로, cross-entropy는 예측 오류를 손실로 바꾼다.
미분과 gradient는 손실을 줄이는 방향을 알려주며, chain rule은 backprop의 핵심이다.
NaN, overflow, gradient explosion은 운영 문제가기 전에 숫자 계산과 gradient 신호가 깨진 증상이다.

17. 출처

최종 수정: 2026-07-09