수학

MATH / 중급 3번

Σ와 첨자, 그리고 einsum: 수식을 그대로 코드로 옮기기

시그마와 첨자를 읽는 규칙을 자유 첨자·더미 첨자로 정리하고, 어텐션 점수와 합성곱 한 칸을 첨자로 완전히 풀어 쓴 뒤 einsum 한 줄로 되돌립니다.

PALDYN Team46 MIN READ

멀티헤드 어텐션의 점수를 배치까지 포함해 계산해야 합니다. 텐서는 (배치, 헤드, 토큰, 차원) 네 축이고, 마지막 축끼리 내적을 해서 (배치, 헤드, 토큰, 토큰)을 만들어야 합니다. 코드를 이렇게 씁니다.

scores = Q @ K.transpose(0, 1, 3, 2)

돌아갑니다. 그런데 잠시 뒤 헤드 축을 앞으로 빼는 리팩터링을 하고 나면 transpose(0, 1, 3, 2)가 맞는지 다시 확신이 안 섭니다. 축이 하나 늘거나 순서가 바뀔 때마다 이 자리를 다시 풀어야 하고, 그때마다 셰이프를 출력해 확인합니다. 코드는 도는데 왜 도는지를 매번 다시 확인하고 있는 상태입니다.

논문의 식에는 이 문제가 없습니다. 식은 처음부터 축의 순서를 안 씁니다. 대신 축마다 이름을 붙이고, 그 이름이 어디에 나타나는지로 계산을 정의합니다.

(QK⊤)ij=∑t=1dkQitKjt(QK^\top)_{ij} = \sum_{t=1}^{d_k} Q_{it} K_{jt}

지난 글에서 이 식의 기호들이 각각 무엇인지는 정리했습니다. 남은 것은 ∑\sum과 첨자입니다. 어떤 첨자가 결과에 남고 어떤 첨자가 합쳐져 사라지는지 — 이 규칙 하나만 알면 위 식을 transpose 없이 그대로 코드로 옮길 수 있습니다.

Σ와 Π

합 기호

시그마의 정의는 간단합니다.

시그마와 for 루프의 대응

∑i=1nai=a1+a2+⋯+an\sum_{i=1}^{n} a_i = a_1 + a_2 + \cdots + a_n

아래에 시작값, 위에 끝값, 오른쪽에 더할 것. 아래에 적힌 ii처럼 한 칸씩 움직이며 항을 고르는 글자를 첨자라고 부릅니다. 코드로 옮기면 그대로 루프이고, 첨자는 루프 변수입니다.

total = 0.0
for i in range(1, n + 1):
    total += a[i]

논문이 범위를 생략하는 일이 잦습니다. ∑iai\sum_i a_i라고만 쓰면 "ii가 가질 수 있는 값 전부"를 뜻하고, 어디까지인지는 aa의 정의에서 옵니다. a∈Rna \in \mathbb{R}^n이면 11부터 nn까지입니다. 범위가 안 적혀 있다고 당황할 필요는 없습니다. 오히려 범위를 안 적었다는 것은 "이 첨자가 움직일 수 있는 곳 전부"라는 뜻이라, 코드에서는 축 하나를 통째로 sum하는 것과 같습니다.

곱 기호

곱 버전도 있습니다. ∏\prod는 더하는 대신 곱합니다.

∏i=1npi=p1p2⋯pn\prod_{i=1}^{n} p_i = p_1 p_2 \cdots p_n

이 기호가 나오는 대표적인 자리가 언어 모델의 문장 확률입니다. 문장 전체의 확률은 토큰마다 "앞의 토큰들이 주어졌을 때 이 토큰이 나올 확률"을 하나씩 곱한 것입니다.

pθ(x1,…,xN)=∏i=1Npθ(xi∣x<i)p_\theta(x_1, \ldots, x_N) = \prod_{i=1}^{N} p_\theta(x_i \mid x_{<i})

그리고 이 곱에 로그를 씌우면 합으로 바뀝니다 — log⁡∏=∑log⁡\log \prod = \sum \log. 사전학습 손실이 곱이 아니라 합으로 적혀 있는 이유가 그것이고, 왜 굳이 로그로 바꾸는지는 18번 글 지수와 로그와 28번 글 최대가능도가 답합니다. 지금은 곱을 합으로 바꾸는 통로가 로그라는 것만 기억하면 됩니다.

빈 합과 빈 곱

범위가 비는 경우가 있습니다. ∑i=10ai\sum_{i=1}^{0} a_i처럼 끝값이 시작값보다 작으면 더할 항이 하나도 없습니다. 이것을 빈 합이라 부르고 값은 00으로 약속합니다. 곱 쪽의 빈 곱은 11입니다. 위의 루프를 보면 약속이 저절로 나옵니다. 합은 total = 0.0에서 출발하니 루프가 한 번도 안 돌면 00이 남고, 곱은 total = 1.0에서 출발하니 11이 남습니다. NumPy도 같아서 np.sum([])는 0.0, np.prod([])는 1.0입니다.

이 약속은 서로 맞물려 있습니다. 빈 곱에 로그를 씌우면 log⁡1=0\log 1 = 0이고, 이것은 빈 합입니다. 앞에서 본 log⁡∏=∑log⁡\log\prod = \sum\log가 항이 하나도 없을 때도 성립하려면 두 값이 정확히 이래야 합니다. 범위를 둘로 쪼개는 ∑i=1n=∑i=1k+∑i=k+1n\sum_{i=1}^{n} = \sum_{i=1}^{k} + \sum_{i=k+1}^{n}도 k=nk = n일 때 뒤쪽이 빈 합이 되어 00을 더하므로 그대로 맞습니다.

코드에서 이 약속이 실제로 걸리는 자리가 있습니다. 패딩 때문에 마스크가 한 줄 전체를 가린 행에서 소프트맥스를 계산하면, 분모가 ∑je−∞\sum_j e^{-\infty}라 사실상 빈 합처럼 00이 되고 0/00/0에서 nan이 나옵니다. 손실을 loss.sum() / mask.sum()으로 평균 낼 때 마스크가 전부 0인 배치가 들어와도 같은 일이 생깁니다. 수식에서는 "빈 합은 0"으로 조용히 넘어가는 자리가, 나눗셈의 분모에 들어가는 순간 사고가 됩니다.

선형성

Σ를 다루는 규칙은 둘이면 대부분 충분합니다.

∑ic ai=c∑iai,∑i(ai+bi)=∑iai+∑ibi\sum_{i} c\,a_i = c \sum_{i} a_i, \qquad \sum_{i} (a_i + b_i) = \sum_{i} a_i + \sum_{i} b_i

첫째는 첨자와 무관한 상수를 합 밖으로 빼는 규칙이고, 둘째는 더해진 것을 두 합으로 쪼개는 규칙입니다. 이 두 성질을 합쳐 Σ의 선형성이라 부릅니다. 첨자가 붙은 유도의 대부분이 이 두 줄을 몇 번 쓰는 것으로 끝납니다.

손으로 하나 따라가 봅니다. x=(2,4,9)x = (2, 4, 9)의 평균은 xˉ=5\bar{x} = 5이고, 평균을 뺀 편차는 (−3,−1,4)(-3, -1, 4)라 더하면 00입니다. 이것이 우연이 아니라는 것을 선형성으로 보일 수 있습니다. 둘째 규칙으로 쪼개면 ∑i(xi−xˉ)=∑ixi−∑ixˉ\sum_i (x_i - \bar{x}) = \sum_i x_i - \sum_i \bar{x}이고, xˉ\bar{x}는 ii와 무관한 상수라 세 번 더하면 3xˉ3\bar{x}입니다. 그러니 15−15=015 - 15 = 0. 정규화 층이 평균을 빼고 나면 합이 0이 된다는 사실이 이 두 줄에서 나옵니다.

조심할 것은 곱입니다. ∑iaibi\sum_i a_i b_i는 (∑iai)(∑ibi)(\sum_i a_i)(\sum_i b_i)가 아닙니다. a=(1,2,3)a = (1,2,3), b=(4,5,6)b = (4,5,6)이면 앞쪽은 4+10+18=324 + 10 + 18 = 32, 뒤쪽은 6×15=906 \times 15 = 90입니다. 밖으로 뺄 수 있는 것은 첨자와 무관한 상수뿐이고, bib_i처럼 첨자를 달고 있는 것은 상수가 아닙니다.

자유 첨자와 더미 첨자

두 종류의 첨자

첨자에는 두 종류가 있고, 이 구별이 이 글의 중심입니다.

자유 첨자와 더미 첨자

(QK⊤)ij=∑tQitKjt(QK^\top)_{ij} = \sum_{t} Q_{it} K_{jt}

  • ii와 jj는 자유 첨자입니다. 등호 왼쪽에도 나타나고 오른쪽에도 나타납니다. 결과에 남는 축이고, 그래서 결과 셰이프는 (n,n)(n, n)입니다.
  • tt는 더미 첨자입니다. ∑\sum 아래에만 있고 왼쪽에는 없습니다. 합쳐져 사라지는 축입니다.

루프로 보면 차이가 더 분명합니다. 자유 첨자는 결과 배열의 칸을 고르는 바깥 루프 변수이고, 더미 첨자는 한 칸의 값을 채우려고 안에서 도는 루프 변수입니다. 바깥 루프가 한 번 돌 때마다 결과에 칸 하나가 생기고, 안쪽 루프는 다 돌고 나면 흔적 없이 사라집니다.

더미 이름 바꾸기

여기서 두 가지 실용적인 규칙이 나옵니다.

규칙 1 — 더미 첨자는 이름을 바꿔도 값이 같습니다. ∑tQitKjt\sum_t Q_{it}K_{jt}와 ∑zQizKjz\sum_z Q_{iz}K_{jz}는 완전히 같은 식입니다. 루프 변수 이름을 바꾼 것과 다르지 않습니다. 논문마다 tt, kk, dd, ℓ\ell 등을 제각각 쓰는 이유고, 이름이 다르다고 다른 식으로 읽으면 안 됩니다.

단서가 하나 있습니다. 새 이름이 바깥에서 이미 자유 첨자로 쓰이고 있으면 안 됩니다. 행렬-벡터 곱 yi=∑jAijxjy_i = \sum_j A_{ij} x_j에서 더미 jj를 kk로 바꾸는 것은 괜찮지만, ii로 바꾸면 ∑iAiixi\sum_i A_{ii} x_i가 됩니다. 이것은 대각 성분과 xx의 내적이라는 전혀 다른 수이고, 게다가 ii에 대해 합이 끝났으니 스칼라입니다. 코드에서 안쪽 루프 변수 이름을 바깥 루프 변수와 같게 지어 바깥 값을 덮어쓴 것과 같은 실수입니다.

첨자 검사

규칙 2 — 자유 첨자는 등호 양변에 똑같이 나타나야 합니다. 왼쪽에 ii가 있는데 오른쪽 어디에도 ii가 없으면 그 식은 틀린 식입니다. 반대로 오른쪽에만 있고 왼쪽에 없는 첨자는 반드시 ∑\sum에 묶여 있어야 합니다. 이것이 수식의 타입 검사입니다. 논문 식을 옮겨 적다가 첨자 하나를 빠뜨리면 이 규칙으로 즉시 잡힙니다.

바로 앞의 실수도 이 검사가 잡습니다. yi=∑iAiixiy_i = \sum_i A_{ii} x_i는 왼쪽에 ii가 있는데 오른쪽의 ii는 전부 ∑\sum에 묶여 사라졌으니, 오른쪽에 남은 자유 첨자가 없습니다. 양변의 자유 첨자 목록이 다르므로 틀린 식입니다.

규칙 2를 쓰면 결과 셰이프도 계산 없이 나옵니다. 왼쪽에 남은 자유 첨자의 개수가 곧 결과의 축 개수입니다. (QK⊤)ij(QK^\top)_{ij}는 자유 첨자가 둘이니 2차원, ∑ijAij\sum_{ij} A_{ij}는 자유 첨자가 없으니 스칼라입니다.

축의 순서

자유 첨자에는 개수 말고 순서도 있습니다. 등호 왼쪽에 SijS_{ij}라고 쓰면 첫 축이 ii, 둘째 축이 jj인 배열을 만든다는 뜻입니다. 같은 오른쪽을 두고 왼쪽을 TjiT_{ji}로 쓰면 첫 축이 jj가 되어 결과는 SS의 전치, 곧 KQ⊤KQ^\top입니다.

식에서는 이 순서가 눈에 잘 안 띕니다. 왼쪽 첨자 두 글자의 순서로만 적히고, 많은 논문은 왼쪽을 아예 QK⊤QK^\top처럼 행렬 이름으로만 쓰기 때문입니다. 뒤에서 볼 einsum 문자열에서는 이 순서가 화살표 오른쪽에 언제나 드러나 있습니다. 축 순서를 실수하는 일이 식보다 문자열에서 적은 이유입니다.

이중합

순서 교환

합이 둘 겹친 것을 이중합이라 하고, 이렇게 씁니다.

∑i=1m∑j=1naij\sum_{i=1}^{m} \sum_{j=1}^{n} a_{ij}

중첩 루프와 같습니다. 안쪽 jj 루프가 먼저 다 돌고, 그다음 바깥 ii가 한 칸 움직입니다. 그런데 논문에서는 이 순서를 아무렇지 않게 바꿔 씁니다.

∑i∑jaij=∑j∑iaij\sum_{i}\sum_{j} a_{ij} = \sum_{j}\sum_{i} a_{ij}

이중합의 순서 교환

왜 되는지는 그림이 답합니다. 두 식은 같은 칸들을 다른 순서로 훑을 뿐이고, 덧셈은 순서를 바꿔도 결과가 같습니다. 유한한 개수의 항을 더하는 한 언제나 성립합니다.

A = rng.normal(size=(9, 11))
A.sum(0).sum(0) == A.sum(1).sum(0)   # 같은 값

단, 유한할 때입니다. 항이 무한히 많으면 순서를 바꿔 값이 달라질 수 있고 — 이런 급수를 조건수렴한다고 부릅니다 — 그 경우를 구별하는 조건이 따로 있습니다. 딥러닝에서 다루는 합은 배치 크기, 토큰 수, 차원 수처럼 전부 유한하므로 마음 놓고 바꿔도 됩니다. 다만 적분이 섞이면 이야기가 달라져서, 기댓값과 미분의 순서를 바꾸는 자리(53번 글 로그 미분 트릭)에서는 조건을 확인하고 넘어갑니다.

max와 log

Σ끼리는 자리를 바꿔도 되고, 선형성에서 본 대로 상수배도 Σ를 드나들 수 있습니다. 하지만 Σ와 바꿔도 되는 것은 거기까지입니다. 가장 흔히 착각하는 것이 max입니다.

A=(1542)A = \begin{pmatrix} 1 & 5 \\ 4 & 2 \end{pmatrix}

행마다 큰 값을 골라 더하면 ∑imax⁡jAij=5+4=9\sum_i \max_j A_{ij} = 5 + 4 = 9입니다. 열마다 먼저 더해서 (5,7)(5, 7)을 만들고 그중 큰 값을 고르면 max⁡j∑iAij=7\max_j \sum_i A_{ij} = 7입니다. 앞쪽은 행마다 따로 가장 좋은 칸을 고를 수 있고, 뒤쪽은 모든 행이 같은 열을 골라야 하니 앞쪽이 언제나 크거나 같습니다. 순서를 바꾸면 값이 달라지는 것입니다.

로그도 Σ를 통과하지 못합니다. log⁡∑iexi\log\sum_i e^{x_i}를 ∑ilog⁡exi=∑ixi\sum_i \log e^{x_i} = \sum_i x_i로 바꿀 수 없습니다. 로그가 곱은 합으로 바꿔 주지만 합은 아무것으로도 바꿔 주지 않기 때문입니다. 그래서 log⁡∑exp⁡\log\sum\exp는 더 줄일 수 없는 한 덩어리이고, 라이브러리에 logsumexp라는 함수가 따로 있습니다.

그 함수가 하는 일은 선형성 하나입니다. 가장 큰 값 m=max⁡ixim = \max_i x_i를 꺼내 exi=emexi−me^{x_i} = e^{m} e^{x_i - m}로 쓰면, eme^{m}은 ii와 무관한 상수라 합 밖으로 나옵니다. 그다음 바깥의 로그가 곱을 합으로 바꿔 m+log⁡∑iexi−mm + \log\sum_i e^{x_i - m}이 됩니다. 지수 안의 값이 전부 0 이하가 되어 넘침이 안 생깁니다. 이 계산은 log-sum-exp 글에서 자세히 다룹니다.

조건부 합

합 기호 아래에 범위 대신 조건을 쓰기도 합니다. ∑i≠jaij\sum_{i \ne j} a_{ij}는 ii와 jj를 둘 다 돌리되 둘이 같은 칸은 건너뛰라는 뜻이고, 이런 꼴을 조건부 합이라 부릅니다. 격자로 보면 대각선을 뺀 칸만 훑는 것입니다.

대각선을 뺀 조건부 합

M=(213041526)M = \begin{pmatrix} 2 & 1 & 3 \\ 0 & 4 & 1 \\ 5 & 2 & 6 \end{pmatrix}

이 행렬의 아홉 칸을 다 더하면 2424이고, 대각선 2+4+6=122 + 4 + 6 = 12를 빼면 ∑i≠jMij=12\sum_{i \ne j} M_{ij} = 12입니다. 조건부 합은 대개 이렇게 "전부 더한 것에서 빼야 할 칸을 뺀 것"으로 계산합니다. 코드에서는 조건을 마스크로 만들어 곱합니다. 대각선이 0이고 나머지가 1인 행렬 1 - np.eye(3)을 원소별로 곱한 뒤 전부 더하면 같은 1212가 나옵니다.

AI 코드에서 이 꼴이 정확히 두 자리에 나옵니다. 하나는 인과 어텐션입니다. ii번 토큰은 자기와 앞의 토큰만 봐야 하므로 점수의 합이 ∑j≤i\sum_{j \le i}로 적히고, 코드에서는 위쪽 삼각형을 −∞-\infty로 덮는 마스크가 됩니다. 다른 하나는 대조학습입니다. 한 배치 안에서 ii번 샘플의 손실 분모는 자기 자신과의 유사도를 뺀 나머지 전부, 곧 ∑j≠i\sum_{j \ne i}로 더합니다. 두 경우 모두 수식의 조건 한 줄이 코드에서는 마스크 행렬 하나가 됩니다.

배치 평균

순서 교환이 실무에서 쓰이는 자리가 하나 있습니다. 배치 손실입니다.

L=1BT∑b=1B∑t=1TℓbtL = \frac{1}{BT}\sum_{b=1}^{B}\sum_{t=1}^{T} \ell_{bt}

배치 안에서 먼저 평균 내고 토큰으로 평균 내든, 반대로 하든 같습니다. 다만 각 배치의 토큰 수가 다르면 이야기가 달라집니다. 패딩이 있는 배치에서 loss.mean(-1).mean()과 loss.sum() / mask.sum()이 다른 값을 주는 것이 그 때문입니다. 순서 교환이 깨진 게 아니라 나누는 수가 달라진 것인데, 첨자로 써 보면 어느 쪽이 의도한 식인지 바로 보입니다. 앞쪽은 문장마다 1Tb∑t\frac{1}{T_b}\sum_t를 먼저 하고 문장 수로 나누니 짧은 문장의 토큰 하나가 긴 문장의 토큰 하나보다 무겁고, 뒤쪽은 모든 토큰을 같은 무게로 셉니다.

아인슈타인 합 규약

생략된 Σ

논문을 읽다 보면 ∑\sum이 아예 없는 식을 만납니다.

yi=Aijxjy_i = A_{ij} x_j

오른쪽에 jj가 두 번 나오는데 왼쪽에는 없습니다. 앞의 규칙 2에 따르면 이건 틀린 식이어야 합니다. 그런데 틀린 게 아니라 생략된 것입니다. 아인슈타인 합 규약은 이렇게 말합니다.

한 항 안에서 같은 첨자가 두 번 나타나면, 그 첨자에 대해 자동으로 합한다.

그래서 위 식은 yi=∑jAijxjy_i = \sum_j A_{ij} x_j와 같고, 이것은 행렬-벡터 곱입니다. 규약이 하는 일은 정확히 하나입니다 — 더미 첨자를 반복으로 표시하고 ∑\sum을 지우는 것. 자유 첨자는 한 번만 나타나고 더미 첨자는 두 번 나타나므로, 세어 보면 어느 쪽인지 알 수 있습니다.

첨자가 나타나는 횟수로 읽기

위 첨자와 아래 첨자

원래 규약은 지금 쓰는 것보다 조금 더 까다로웠습니다. 물리학에서는 첨자를 위와 아래에 나눠 달고, 같은 글자가 위에 한 번 아래에 한 번 나타날 때만 합을 겁니다. 행렬-벡터 곱은 yi=Aij xjy^i = A^i{}_j\, x^j처럼 적힙니다. 위 첨자와 아래 첨자는 좌표를 바꿀 때 서로 반대로 변하는 두 종류의 양을 가르는 표시이고, 둘을 한 쌍으로 묶어 합해야 좌표를 바꿔도 결과가 변하지 않습니다.

머신러닝은 이 구별을 버렸습니다. 우리가 다루는 공간은 거의 언제나 직교하는 축에 같은 눈금을 쓰는 유클리드 공간이고, 거기서는 위아래 두 종류의 성분이 같은 수가 되어 가를 필요가 없기 때문입니다. 그래서 yi=Aijxjy_i = A_{ij} x_j처럼 전부 아래에 적고 "두 번 나오면 합"만 남깁니다. 물리 교재와 딥러닝 논문을 함께 읽다가 첨자 높이가 다른 것을 보면 이 차이입니다.

세 번 나오는 첨자

같은 첨자가 세 번 나오면 어떻게 될까요. aibicia_i b_i c_i는 규약으로는 읽을 수 없는 식입니다. 규약은 한 항 안에서 한 첨자가 많아야 두 번 나온다고 전제하므로, 세 번 나온 식은 잘못 적힌 것으로 봅니다. 셋을 곱해서 더하고 싶으면 ∑iaibici\sum_i a_i b_i c_i처럼 Σ를 다시 적어야 합니다.

einsum은 여기서 규약과 갈라집니다. np.einsum('i,i,i->', a, b, c)는 오류 없이 세 벡터를 칸마다 곱해서 더합니다. a=(1,2,3)a = (1,2,3), b=(4,5,6)b = (4,5,6), c=(7,8,9)c = (7,8,9)이면 28+80+162=27028 + 80 + 162 = 270입니다. einsum에서는 몇 번 나오느냐가 아니라 화살표 오른쪽에 적혔느냐가 합을 정하기 때문입니다. 이 규약이 코드로 넘어온 것이 einsum이지만, 넘어오면서 규칙의 기준이 횟수에서 출력 목록으로 바뀌었습니다.

einsum

문자열 세 단계

np.einsum과 torch.einsum은 첨자 규약을 문자열로 받습니다. 만드는 절차는 기계적입니다.

  1. 입력 텐서마다 축에 글자를 붙인다. 왼쪽부터 순서대로, 축 하나에 글자 하나. 여러 텐서에서 같은 이름을 쓰면 그 축의 길이가 같다는 뜻입니다.
  2. -> 오른쪽에 결과에 남길 글자를 적는다. 적은 순서가 곧 결과 축의 순서입니다.
  3. 오른쪽에 안 적은 글자는 합쳐진다.

3단계가 핵심입니다. -> 오른쪽에 안 적으면 사라지고, 사라진다는 것은 그 축에 대해 더한다는 뜻입니다. 자유 첨자와 더미 첨자의 구별이 문자열의 왼쪽·오른쪽으로 그대로 옮겨진 것입니다.

이 규칙 하나로 웬만한 텐서 연산이 다 표현됩니다.

연산 수식 einsum
내적 ∑iviwi\sum_i v_i w_i np.einsum('i,i->', v, w)
외적 viwjv_i w_j np.einsum('i,j->ij', v, w)
전치 MjiM_{ji} np.einsum('ij->ji', M)
행 합 ∑jMij\sum_j M_{ij} np.einsum('ij->i', M)
대각 성분 MiiM_{ii} np.einsum('ii->i', M)
대각합 ∑iMii\sum_i M_{ii} np.einsum('ii->', M)
행렬곱 ∑jAijBjk\sum_j A_{ij}B_{jk} np.einsum('ij,jk->ik', A, B)
원소별 곱 AijBijA_{ij}B_{ij} np.einsum('ij,ij->ij', A, B)

표에서 대각 성분과 대각합을 비교해 보면 규칙이 선명해집니다. 'ii->i'는 반복된 글자를 오른쪽에 남겨 두었으니 합치지 않고 그 자리만 뽑고, 'ii->'는 안 남겼으니 합칩니다. 왼쪽이 같아도 오른쪽이 다르면 연산이 다릅니다 — 오른쪽이 무엇을 남길지 결정합니다.

QKᵀ 풀어 쓰기

이제 처음의 어텐션 점수로 돌아갑니다. 먼저 첨자로 완전히 풀어 씁니다. 축 이름을 붙이는 것부터 시작합니다.

  • QQ의 축: 토큰 ii, 차원 tt → it
  • KK의 축: 토큰 jj, 차원 tt → jt
  • 결과의 축: 질의 토큰 ii, 키 토큰 jj → ij

KK의 토큰 축에 ii가 아니라 jj를 붙인 것이 유일한 판단입니다. 두 토큰 축은 길이가 같지만 같은 것을 세지 않습니다. ii번 질의와 jj번 키의 모든 조합이 필요하니 이름을 달리 줘야 하고, 만약 둘 다 ii로 두면 'it,it->i'가 되어 같은 번호의 질의와 키만 짝지은 대각 성분만 남게 됩니다.

차원 축은 둘 다 tt입니다. 같은 이름을 두 번 썼고 오른쪽에 안 적었으니 합쳐집니다. 그것이 내적입니다.

(QK⊤)ij=∑tQitKjt⟶’it,jt->ij’(QK^\top)_{ij} = \sum_{t} Q_{it}K_{jt} \quad\longrightarrow\quad \texttt{'it,jt->ij'}

세 겹 루프로 직접 짠 것과 같은지 확인합니다.

import numpy as np

rng = np.random.default_rng(0)
n, dk = 4, 6
Q = rng.normal(size=(n, dk))
K = rng.normal(size=(n, dk))

S = np.zeros((n, n))
for i in range(n):
    for j in range(n):
        total = 0.0
        for t in range(dk):
            total += Q[i, t] * K[j, t]
        S[i, j] = total

print(np.allclose(S, np.einsum('it,jt->ij', Q, K)))   # True
print(np.allclose(S, Q @ K.T))                        # True
print(np.allclose(np.einsum('it,jt->ij', Q, K),
                  np.einsum('iz,jz->ij', Q, K)))      # True — 더미는 이름 무관

세 줄 모두 True입니다. 마지막 줄이 규칙 1의 확인입니다. 루프 코드의 바깥 두 줄이 자유 첨자 ii, jj이고 안쪽 한 줄이 더미 첨자 tt라는 것도 눈으로 대조해 볼 만합니다.

이제 배치와 헤드를 붙입니다. 실제 텐서는 (B, H, T, D) 네 축입니다. 첨자를 앞에 두 개 더 붙이기만 하면 됩니다.

Sbhij=∑dQbhidKbhjd⟶’bhid,bhjd->bhij’S_{bhij} = \sum_{d} Q_{bhid} K_{bhjd} \quad\longrightarrow\quad \texttt{'bhid,bhjd->bhij'}

B, H, T, D = 2, 3, 5, 7
Qb = rng.normal(size=(B, H, T, D))
Kb = rng.normal(size=(B, H, T, D))

Sb = np.einsum('bhid,bhjd->bhij', Qb, Kb)
print(Sb.shape)                                        # (2, 3, 5, 5)
print(np.allclose(Sb, Qb @ Kb.transpose(0, 1, 3, 2)))  # True

두 줄이 같은 값을 줍니다. 다른 것은 읽는 데 드는 노력입니다. transpose(0, 1, 3, 2)는 축 번호를 세어야 검증되지만, 'bhid,bhjd->bhij'는 논문 식의 첨자를 그대로 옮겨 적은 것이라 눈으로 대조하면 끝납니다. 배치 축이 하나 더 늘어도 글자 하나를 앞에 붙이면 되고, 헤드 축을 뒤로 옮겨도 문자열 안의 글자 위치만 바꾸면 됩니다. 축 순서를 다시 계산할 일이 없어집니다.

생략 부호

배치와 헤드처럼 계산에 참여하지 않고 그대로 따라가기만 하는 축은 이름조차 안 붙여도 됩니다. 문자열에 점 세 개 ...를 쓰면 "이 자리의 축들은 몇 개든 통째로 넘긴다"는 뜻이 되고, 이것을 생략 부호라고 부릅니다.

S1 = np.einsum('...id,...jd->...ij', Qb, Kb)
S2 = np.einsum('...id,...jd->...ij', Qb[0, 0], Kb[0, 0])
print(S1.shape, S2.shape)                             # (2, 3, 5, 5) (5, 5)

같은 문자열이 네 축 텐서에도, 배치와 헤드를 떼어 낸 두 축 행렬에도 그대로 들어갑니다. 실무 코드에서 어텐션 점수를 이 꼴로 가장 많이 쓰는 이유입니다. 앞쪽에 무엇이 몇 개 붙어 있든 함수가 신경 쓰지 않으므로, 배치가 없는 디버깅 입력과 실제 학습 입력을 한 함수로 처리할 수 있습니다. 대신 ...에 묶인 축은 이름이 없어 결과 문자열에서 순서를 바꿀 수 없습니다. 배치 축을 뒤로 보내야 하면 그때는 글자를 붙여야 합니다.

출력 생략

->와 그 오른쪽은 생략할 수 있습니다. 생략하면 einsum이 출력을 스스로 정하는데, 그 규칙은 "한 번만 나온 글자를 알파벳 순으로 남긴다"입니다. np.einsum('ij,jk', A, B)는 j가 두 번 나와 합쳐지고 i, k가 알파벳 순으로 남아 행렬곱이 됩니다. 이 정도면 편리하지만, 같은 규칙이 조용한 사고를 만들기도 합니다.

첫째, 알파벳 순이 결과 축의 순서를 바꿉니다. np.einsum('ji', M)은 아무 연산도 안 할 것처럼 보이지만 출력이 'ij'로 정해져 MM의 전치를 돌려줍니다. 둘째, 두 번 나온 글자는 전부 합쳐집니다. 어텐션 점수를 np.einsum('bhid,bhjd', Qb, Kb)로 쓰면 b와 h도 두 번 나왔으니 배치와 헤드까지 더해져 결과가 (5, 5) 하나로 쪼그라듭니다. 오류도 경고도 없습니다. 그래서 -> 오른쪽은 생략할 수 있어도 언제나 적는 편이 좋습니다. 적어 두면 문자열이 곧 결과 셰이프의 선언이 됩니다.

합성곱 한 칸

첨자로 쓴 합성곱

같은 절차가 합성곱에도 그대로 적용됩니다. 출력 한 칸의 정의는 이렇습니다.

Yn,o,y,x=∑c∑ky∑kxXn, c, y+ky, x+kx  Wo, c, ky, kxY_{n,o,y,x} = \sum_{c}\sum_{k_y}\sum_{k_x} X_{n,\,c,\,y+k_y,\,x+k_x}\; W_{o,\,c,\,k_y,\,k_x}

자유 첨자는 nn(배치), oo(출력 채널), yy, xx(출력 위치) 넷이고, 더미 첨자는 cc(입력 채널), kyk_y, kxk_x(커널 안의 위치) 셋입니다. 결과가 4차원인 이유가 자유 첨자 넷이고, 세 겹 합이 붙은 이유가 더미 첨자 셋입니다.

한 가지 걸리는 것이 XX의 첨자에 있는 y+kyy+k_y입니다. 첨자 자리에 덧셈이 들어가 있어서 einsum 문자열로 바로 못 옮깁니다. 이럴 때는 겹치는 창을 먼저 꺼내 축으로 만들어 둡니다.

N, C, Hh, Ww = 2, 3, 6, 6
O, KH, KW = 4, 3, 3
X = rng.normal(size=(N, C, Hh, Ww))
W = rng.normal(size=(O, C, KH, KW))

# (N, C, OH, OW, KH, KW) — y+ky 를 미리 펼쳐 축으로 만든다
patches = np.lib.stride_tricks.sliding_window_view(X, (KH, KW), axis=(2, 3))
print(patches.shape)                       # (2, 3, 4, 4, 3, 3)

Y = np.einsum('ncyxkl,ockl->noyx', patches, W)
print(Y.shape)                             # (2, 4, 4, 4)

문자열을 읽어 봅니다. ncyxkl에서 n, y, x는 오른쪽에 남았고 c, k, l은 안 남았으니 합쳐집니다. ockl에서 o는 남고 c, k, l은 두 입력에 모두 나타나며 안 남았으니 합쳐집니다. 수식의 자유 첨자 넷과 더미 첨자 셋이 문자열에 그대로 있습니다.

이것이 여섯 겹 루프와 같은지 확인하면 True가 나옵니다. 그리고 이 형태가 실제로 합성곱을 행렬곱으로 구현하는 방법의 뼈대입니다. 창을 전부 펼쳐 큰 행렬을 만든 뒤 가중치와 한 번에 곱하는 이 방법을 im2col이라 부릅니다. 첨자를 풀어 쓰는 순간 "합성곱은 사실 큰 행렬곱이다"라는 문장이 계산으로 보입니다.

보폭과 팽창

위 정의는 창이 한 칸씩 움직이고 커널 칸이 빈틈없이 붙어 있는 가장 단순한 경우입니다. 실제 합성곱 층에는 두 값이 더 붙습니다. 창이 한 번에 몇 칸씩 건너뛰는가가 보폭(stride) ss이고, 커널의 칸 사이를 몇 칸씩 벌려 읽는가가 팽창(dilation) dd입니다. 둘 다 첨자의 덧셈 자리에 곱으로 들어갑니다.

Yn,o,y,x=∑c∑ky∑kxXn, c, ys+kyd, xs+kxd  Wo, c, ky, kxY_{n,o,y,x} = \sum_{c}\sum_{k_y}\sum_{k_x} X_{n,\,c,\,y s + k_y d,\,x s + k_x d}\; W_{o,\,c,\,k_y,\,k_x}

s=d=1s = d = 1이면 앞의 식으로 돌아옵니다. 한 줄만 떼어 길이 6짜리 입력에 길이 3짜리 커널을 대 봅니다. 보폭 1, 팽창 1이면 출력 yy번 칸이 입력 y,y+1,y+2y, y+1, y+2를 읽으므로 출력은 0번부터 3번까지 네 칸입니다. 보폭을 2로 올리면 출력 0번이 입력 0·1·2를, 출력 1번이 2·3·4를 읽고, 다음 창은 4·5·6이라 입력 밖으로 나가므로 출력은 두 칸에서 끝납니다. 보폭은 1로 두고 팽창을 2로 올리면 출력 0번이 0·2·4를, 1번이 1·3·5를 읽어 역시 두 칸입니다.

보폭과 팽창이 읽는 입력 칸

세 경우를 한 식으로 묶으면 출력 길이는 ⌊(H−d(K−1)−1)/s⌋+1\lfloor (H - d(K-1) - 1)/s \rfloor + 1입니다. 팽창은 커널이 덮는 폭을 d(K−1)+1d(K-1)+1로 넓히고, 보폭은 그 폭이 들어가는 자리 수를 ss로 나눕니다. 위 숫자를 넣으면 H=6H = 6, K=3K = 3에서 순서대로 4, 2, 2가 나옵니다.

코드로는 앞의 sliding_window_view 결과를 잘라 쓰면 됩니다. 보폭은 창의 위치 축을 ::s로 건너뛰는 것이고, 팽창은 폭 d(K−1)+1d(K-1)+1짜리 창을 꺼낸 뒤 창 안의 축을 ::d로 건너뛰는 것입니다. 이렇게 만든 patches에 같은 문자열 'ncyxkl,ockl->noyx'를 쓰면 되고, 여섯 겹 루프로 짠 정의와 세 경우 모두 일치합니다. 첨자의 식이 바뀌어도 einsum 문자열은 안 바뀝니다. 바뀌는 것은 창을 꺼내는 쪽뿐입니다.

창 뷰와 복사

sliding_window_view는 데이터를 복사하지 않습니다. 원래 배열의 같은 메모리를 다른 보폭으로 읽는 뷰를 돌려줄 뿐이라, 겹치는 창들이 같은 원소를 몇 번씩 가리켜도 메모리는 늘지 않습니다. 위 예에서 patches가 스스로 보고하는 크기는 6,912바이트로 XX의 1,728바이트의 네 배지만, 실제로 새로 잡힌 메모리는 없습니다.

복사는 einsum이 그 뷰를 행렬곱 커널로 넘길 때 일어납니다. 행렬곱 라이브러리는 메모리에 빈틈없이 놓인 배열을 받기 때문에, 겹친 창을 펼친 진짜 배열을 만들어야 합니다. 입력 (8, 64, 64, 64)에 3×3 커널을 대고 재 보면, 약 17MB짜리 입력이 펼쳐진 창으로는 약 142MB가 됩니다. NumPy의 einsum은 optimize=True일 때 이 복사를 하고 행렬곱으로 계산하며, 기본값에서는 복사 없이 뷰를 그대로 도는 대신 훨씬 느립니다. 이 컨테이너에서 같은 계산이 0.09초와 2.7초였습니다. im2col의 메모리 값이 바로 이 복사이고, 메모리와 속도를 맞바꾸는 자리입니다.

정리

세 가지 주의

지금까지의 규칙을 다시 모으면, 수식을 읽을 때는 자유 첨자와 더미 첨자를 가르고, 더미 이름은 바꿔도 되지만 자유 첨자와 겹치면 안 되며, Σ와 자리를 바꿔도 되는 것은 다른 Σ와 상수배뿐입니다. 코드로 옮길 때는 세 가지를 더 조심합니다.

첫째, 축 순서를 바꾸는 데는 비용이 듭니다. 'bhid,bhjd->bijh'처럼 결과 축 순서를 바꾸면 메모리 재배치가 일어납니다. 문자열이 짧다고 연산이 싼 것은 아닙니다.

둘째, 세 개 이상을 한 번에 곱할 때는 순서가 성능을 가릅니다. np.einsum('ij,jk,kl->il', A, B, C)는 (AB)C(AB)C로 계산하느냐 A(BC)A(BC)로 계산하느냐에 따라 연산량이 크게 달라집니다. NumPy는 기본적으로 경로를 찾지 않으므로 optimize=True를 주어야 좋은 순서를 찾습니다. PyTorch의 torch.einsum은 기본으로 경로 최적화를 합니다. 왜 결합 순서가 연산량을 바꾸는지는 10번 글 행렬곱 네 가지 시선에서 계산으로 확인합니다.

셋째, 반복된 첨자를 오른쪽에 남기는 것은 합이 아니라 추출입니다. 'ii->i'가 대각 성분을 뽑는다는 것을 앞에서 봤습니다. 이 동작은 아인슈타인 규약 원래 정의에는 없고 einsum이 확장한 부분이라, 논문 식을 옮길 때는 "이 반복이 합인가 추출인가"를 한 번 확인하는 게 좋습니다.

연습

  1. 다음 식에서 자유 첨자와 더미 첨자를 가르고, 결과의 축 개수와 einsum 문자열을 적으세요. ck=∑i∑jAkiBijxjc_{k} = \sum_{i}\sum_{j} A_{ki} B_{ij} x_j
    자유 첨자는 왼쪽에 남은 kk 하나라 결과는 1차원 벡터입니다. ii와 jj는 Σ에 묶인 더미 첨자입니다. 문자열은 'ki,ij,j->k'이고, 계산은 ABxABx와 같습니다.
  2. np.einsum('ij,ij->i', A, B)가 무엇을 계산하는지 수식으로 적으세요.
    ∑jAijBij\sum_j A_{ij} B_{ij}입니다. j가 오른쪽에 없으니 합쳐지고 i는 남습니다. 두 행렬의 같은 번호 행끼리 내적한 값을 행마다 하나씩 모은 벡터이고, (A * B).sum(1)과 같습니다.
  3. zi=∑iWijhjz_i = \sum_{i} W_{ij} h_j는 첨자 검사를 통과하지 못합니다. 어디가 틀렸고 어떻게 고쳐야 하나요?
    Σ가 ii에 걸려 있어 오른쪽에서 ii가 사라지고, 대신 jj가 Σ에 안 묶인 채 남습니다. 양변의 자유 첨자가 ii와 jj로 어긋납니다. 합을 jj에 걸어 zi=∑jWijhjz_i = \sum_j W_{ij} h_j로 써야 행렬-벡터 곱이 됩니다.
  4. M=(312401257)M = \begin{pmatrix} 3 & 1 & 2 \\ 4 & 0 & 1 \\ 2 & 5 & 7 \end{pmatrix}일 때 ∑i≠jMij\sum_{i \ne j} M_{ij}를 구하세요.
    15. 아홉 칸의 합이 25이고 대각선이 3+0+7=103 + 0 + 7 = 10이므로 25−10=1525 - 10 = 15입니다.
  5. B=(3014)B = \begin{pmatrix} 3 & 0 \\ 1 & 4 \end{pmatrix}에서 ∑imax⁡jBij\sum_i \max_j B_{ij}와 max⁡j∑iBij\max_j \sum_i B_{ij}를 각각 구하세요.
    앞쪽은 행마다 큰 값 3과 4를 더해 7, 뒤쪽은 열 합 (4,4)(4, 4) 중 큰 값이라 4입니다. 순서를 바꾸면 값이 달라집니다.
  6. X의 셰이프가 (3, 4), Y가 (5, 4)일 때 np.einsum('nd,md', X, Y)의 결과 셰이프와 계산을 적으세요.
    (5, 3)입니다. 출력을 생략했으니 한 번만 나온 m, n이 알파벳 순으로 남아 결과 첨자가 mn이 되고, d는 합쳐집니다. 곧 YX⊤YX^\top이고, 'nd,md->nm'으로 적었을 때의 XY⊤XY^\top과 서로 전치입니다.
  7. 길이 9짜리 입력에 길이 3짜리 커널을 댑니다. 보폭 2·팽창 1일 때와 보폭 1·팽창 2일 때의 출력 길이를 구하세요.
    보폭 2이면 ⌊(9−2−1)/2⌋+1=4\lfloor (9 - 2 - 1)/2 \rfloor + 1 = 4, 팽창 2이면 커널이 덮는 폭이 5라 ⌊(9−4−1)/1⌋+1=5\lfloor (9 - 4 - 1)/1 \rfloor + 1 = 5입니다.

다시 그 코드로

처음의 코드로 돌아갑니다.

scores = Q @ K.transpose(0, 1, 3, 2)

이 줄이 왜 맞는지 이제 축 번호를 세지 않고 답할 수 있습니다. transpose(0, 1, 3, 2)는 KK의 토큰 축과 차원 축을 맞바꿔, 행렬곱이 마지막 축끼리 내적하게 만드는 준비입니다. 그리고 애초에 이렇게 쓰면 다시 확인할 일이 없습니다.

scores = np.einsum('bhid,bhjd->bhij', Q, K)

논문의 ∑dQbhidKbhjd\sum_d Q_{bhid}K_{bhjd}와 이 문자열은 같은 것을 다른 문법으로 쓴 것입니다. 축의 순서가 아니라 축의 이름으로 계산을 지정하기 때문에, 텐서 레이아웃이 바뀌어도 식은 그대로입니다. 헤드 축을 앞으로 빼는 리팩터링을 해도 문자열의 글자 자리만 옮기면 되고, 배치가 없는 입력까지 받아야 하면 '...id,...jd->...ij'로 바꾸면 됩니다.

여기까지가 수식을 읽는 데 필요한 문법입니다. 글자 모양으로 자료형을 읽고, 첨자로 축을 읽고, 시그마로 무엇이 사라지는지 읽습니다. 이제 문법 말고 대상 차례입니다. 임베딩 한 줄이 왜 그냥 float 배열이 아니라 벡터인지 — 그 구별이 무엇을 보장하길래 "king − man + woman"이 말이 되는지 — 가 다음 글의 질문입니다.


읽어주셔서 감사합니다. 😊

LATEST

수학의 최신 글

수학2026.11.17

다양체 위의 최적화: 직교 제약과 Muon의 직교화가 하는 일

차트·접공간·리만 계량·측지선·후퇴로 다양체를 세우고, 스티펠·그라스만·양정치 행렬·확률 단체의 접공간과 사영을 계산한 뒤, 리만 그래디언트가 유클리드 그래디언트의 접공간 사영임을 증명하고 극분해 후퇴와 뉴턴–슐츠 반복의 수렴 조건을 다룹니다.

고급46 MIN
수학2026.11.17

프리컨디셔닝의 이론: Adam에서 K-FAC·Shampoo·Muon까지 한 줄로

갱신 −ηP⁻¹∇를 노름의 최급강하로 읽고 헤세·가우스–뉴턴·피셔·경험적 피셔의 관계를 정리한 뒤, 준뉴턴과 3차 정규화, K-FAC의 크로네커 인수분해와 그 독립 가정, Shampoo의 −1/4 지수, Muon의 스펙트럴 노름 유도를 차례로 세워 이들이 어디서 일치하는지 보입니다.

고급41 MIN
수학2026.11.17

확률적 근사와 SGD의 연속 극한: 수렴한다는 말의 정확한 뜻

로빈스–먼로 조건과 마팅게일 잡음으로 SGD의 수렴을 정확히 정의하고, 볼록·강볼록·PL·비볼록에서의 수렴률과 오라클 하한을 계산한 뒤, SGD를 확률미분방정식으로 읽어 학습률/배치가 온도가 되는 관점과 안정성의 가장자리를 다룹니다.

고급48 MIN