인덱스 표기와 NumPy einsum의 기초
목차
np.einsum 함수 np.einsum 기초 이 자료에서 $[\boldsymbol A]$, $[\boldsymbol x]$는 행렬·벡터의 성분을 모은 배열을 뜻한다. 행렬곱은 $[\boldsymbol A][\boldsymbol x]$처럼 붙여 쓴다.
11·12장에서 배운 내적, 행렬–벡터곱과 행렬곱을 인덱스로 간단히 다시 쓴다. 새로운 계산법을 많이 추가하기보다, 반복되는 인덱스는 더하고 결과에 남는 인덱스는 유지한다는 한 가지 원리를 이해하는 데 초점을 둔다. 마지막에는 같은 행렬–벡터곱이 간단한 인공신경망(ANN)의 한 층에서 어떻게 사용되는지 살펴본다.
np.einsum 표현을 읽을 수 있다.np.einsum 함수np.einsum 공식 문서는 영문이므로, 처음 읽을 때는 한국어 아인슈타인 합 표기와 einsum 예제를 함께 참고할 수 있다.
Einstein summation convention은 우리말로 흔히 아인슈타인 합 규약이라고 한다. 여기서 convention은 수학적 법칙이라기보다, 한 항에서 같은 첨자가 두 번 나타나면 그 첨자에 대해 합을 취하기로 한 표기상의 약속을 뜻한다. 이 약속을 이용하면 벡터와 행렬 연산의 합 기호($\sum$)를 생략하여 수식을 간결하게 쓸 수 있다.
아래 수식에서는 벡터를 $\boldsymbol a$처럼 굵게 쓰고, 스칼라와 개별 성분은 $a$, $a_i$처럼 보통 굵기로 쓴다. 수식 아래에 붙이는 성분 번호를 첨자라고 하며, 이 장에서는 코드와 연결하기 위해 인덱스라고도 부른다.
이 장의 수식에서는 성분 번호를 1부터, Python 코드에서는 0부터 센다. 예를 들어 수식의 $a_1$은 코드의 a[0]이다.
12장의 행렬–벡터곱을 다시 쓰면
\[c_i=\sum_{j=1}^{n}A_{ij}v_j\]이다. $i$는 결과의 성분을 선택하는 자유 인덱스(free index), $j$는 합을 구한 뒤 사라지는 합산 인덱스(summation index)다. 이 표기 약속에서는 한 항 안에서 두 번 나타나는 합산 인덱스의 합 기호를 생략하여 $c_i=A_{ij}v_j$로 쓴다. 반면 $c_i=a_i+b_i$에서는 오른쪽의 각 항에 $i$가 한 번씩 나타나므로 $i$를 합산하지 않는다. 인덱스의 반복은 등식 전체가 아니라 각 항 안에서 판단한다.

그림: 파란색 자유 인덱스 $i$는 결과 $c_i$에 남고, 주황색 합산 인덱스 $j$는 대응하는 성분을 곱해 더한 뒤 결과에서 사라진다.
11장에서는 벡터의 성분별 연산과 내적을 배웠고, 12장에서는 행렬의 각 행과 벡터의 내적을 모아 행렬–벡터곱을 만들고 이를 행렬곱으로 확장했다. 이 장에서는 계산법을 다시 익히기보다, 같은 연산에서 어떤 인덱스가 결과에 남고 어떤 인덱스를 합산하는지 읽는다.
| 앞에서 배운 연산 | 인덱스 표현 | 인덱스의 역할 |
|---|---|---|
| 벡터의 합 | $c_i=a_i+b_i$ | $i$가 결과에 남는다. |
| 벡터와 스칼라의 곱 | $b_i=ca_i$ | $i$가 결과에 남는다. |
| 벡터의 크기 | $\lVert\boldsymbol a\rVert=\sqrt{a_i a_i}$ | 반복된 $i$를 합산하여 스칼라를 만든다. |
| 벡터의 내적 | $c=a_i b_i$ | 반복된 $i$를 합산하여 스칼라를 만든다. |
| 행렬–벡터곱 | $c_i=A_{ij}v_j$ | $i$는 남고 $j$는 합산한다. |
| 행렬곱 | $C_{ij}=A_{ik}B_{kj}$ | $i,j$는 남고 $k$는 합산한다. |
앞의 두 행처럼 한 항에서 인덱스가 한 번 나타나면 그 인덱스는 결과의 위치를 정한다. 뒤의 네 행처럼 한 항에서 인덱스가 두 번 나타나면 이 표기 약속에 따라 그 인덱스를 합산한다. 이 구분이 13장의 새 내용이며, 다음 절부터 익숙한 연산을 반복문과 np.einsum으로 비교한다.
11장에서 배운 내적은 대응하는 성분을 곱해 모두 더하므로 결과가 스칼라다.
\[c=\sum_{i=1}^{n}a_i b_i=a_i b_i\]a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
c_loop = 0
for i in range(len(a)):
c_loop += a[i] * b[i]
c_matmul = a @ b
c_einsum = np.einsum('i,i->', a, b)
print(c_loop, c_matmul, c_einsum) # 32 32 32
반복문에서 사라지는 i가 합산 인덱스다. einsum에서도 i를 -> 뒤에 쓰지 않았으므로 모든 성분을 더해 스칼라를 만든다.
12장에서 행렬의 각 행과 벡터의 내적을 계산하여 새 벡터를 만들었다.
\[c_i=\sum_{j=1}^{n}A_{ij}v_j=A_{ij}v_j\]A = np.array([[2, 1],
[3, 1]])
v = np.array([3, 1])
c_loop = np.zeros(A.shape[0], dtype=int)
for i in range(A.shape[0]):
for j in range(A.shape[1]):
c_loop[i] += A[i, j] * v[j]
c_matmul = A @ v
c_einsum = np.einsum('ij,j->i', A, v)
print(c_loop) # [7 10]
print(np.array_equal(c_loop, c_matmul))
print(np.array_equal(c_loop, c_einsum))
i는 결과 벡터의 위치를 정하므로 남고, j는 한 행의 성분을 더한 뒤 사라진다. 따라서 'ij,j->i'는 12장의 A @ v를 인덱스로 그대로 적은 표현이다.
12장의 행렬곱은 두 행렬에서 서로 대응하는 $k$ 인덱스에 대해 곱한 값을 더한다.
\[C_{ij}=\sum_{k=1}^{n}A_{ik}B_{kj}=A_{ik}B_{kj}\]A = np.array([[1, 2],
[3, 4]])
B = np.array([[5, 6],
[7, 8]])
C_matmul = A @ B
C_einsum = np.einsum('ik,kj->ij', A, B)
print(C_matmul)
# [[19 22]
# [43 50]]
print(np.array_equal(C_matmul, C_einsum)) # True
i와 j는 결과 행렬의 두 축으로 남고, k는 합산한다. 이처럼 입력 인덱스와 출력 인덱스를 비교하면 결과의 shape도 예측할 수 있다.
np.einsum 기초np.einsum은 배열의 각 축에 i, j, k 같은 이름을 붙여 어느 인덱스를 결과에 남기고 어느 인덱스를 합산할지 적는 함수다. 처음에는 다음 세 가지 표현만 읽을 수 있으면 충분하다.
| 계산 | einsum 표현 | 익숙한 NumPy 표현 | 결과 |
|---|---|---|---|
| 벡터 내적 | np.einsum('i,i->', a, b) | a @ b | 스칼라 |
| 행렬–벡터곱 | np.einsum('ij,j->i', A, v) | A @ v | 벡터 |
| 행렬곱 | np.einsum('ik,kj->ij', A, B) | A @ B | 행렬 |
문자열은 다음 순서로 읽는다.
-> 뒤의 글자는 결과에 남는 인덱스다.예를 들어 'ij,j->i'에서 j는 입력에만 있으므로 합산하고, i는 출력에 남으므로 결과는 벡터가 된다.
두 벡터의 원소별 곱은 각 위치의 곱을 그대로 남긴 벡터이고, 내적은 그 곱을 모두 더한 스칼라다.
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
elementwise = np.einsum('i,i->i', a, b)
dot = np.einsum('i,i->', a, b)
print(elementwise) # [ 4 10 18]
print(dot) # 32
'i,i->i'는 i를 결과에 남기므로 a * b와 같고, 'i,i->'는 i를 결과에서 없애 합산하므로 a @ b와 같다. 단순한 내적이나 행렬곱에서는 @가 더 읽기 쉽다. einsum은 수식의 인덱스와 코드를 직접 비교하고 싶을 때 유용하다.
'ik,kj->ij'와 'ik,jk->ij'의 차이두 표현은 모두 k를 합산하고 i,j를 결과에 남긴다. 그러나 두 번째 배열에서 인덱스를 붙이는 순서가 다르므로 계산도 달라진다.
| 표현 | 두 번째 배열에서 사용하는 성분 | 계산의 의미 | 같은 NumPy 표현 |
|---|---|---|---|
'ik,kj->ij' | $B_{kj}$ | $A$의 $i$번째 행과 $B$의 $j$번째 열의 내적 | A @ B |
'ik,jk->ij' | $B_{jk}$ | $A$의 $i$번째 행과 $B$의 $j$번째 행의 내적 | A @ B.T |
같은 $2\times2$ 배열을 사용하여 결과를 비교해 보자.
A = np.array([[1, 2],
[3, 4]])
B = np.array([[5, 6],
[7, 8]])
C = np.einsum('ik,kj->ij', A, B)
D = np.einsum('ik,jk->ij', A, B)
print(C)
# [[19 22]
# [43 50]]
print(D)
# [[17 23]
# [39 53]]
print(np.array_equal(C, A @ B)) # True
print(np.array_equal(D, A @ B.T)) # True
첫 번째 식의 $C_{11}$은 $A$의 첫 번째 행 $[1,2]$와 $B$의 첫 번째 열 $[5,7]^T$를 내적하므로 $1\times5+2\times7=19$다. 두 번째 식의 $D_{11}$은 $A$와 $B$의 첫 번째 행 $[1,2]$, $[5,6]$을 내적하므로 $1\times5+2\times6=17$이다. 즉, kj를 jk로 바꾸는 것은 단순한 글자 순서 변경이 아니라 두 번째 배열을 전치하여 사용하는 것과 같다.
인공신경망(artificial neural network, ANN)의 한 층은 입력값에 가중치를 곱해 더하고 편향(bias)을 더하는 계산으로 시작한다. 입력이 두 개이고 뉴런이 두 개인 가장 간단한 경우를 생각하자.
\[\boldsymbol z=\boldsymbol W\boldsymbol x+\boldsymbol b, \qquad z_i=W_{ij}x_j+b_i\]
그림: 각 입력 $x_j$는 가중치 $W_{ij}$를 통해 각 뉴런의 가중합 $z_i$에 연결된다. 편향 $b_i$를 더한 뒤 ReLU를 적용하여 출력 $y_i$를 얻는다.
\[\boldsymbol W= \begin{bmatrix} 0.5&1.0\\ -1.0&2.0 \end{bmatrix}, \qquad \boldsymbol x= \begin{bmatrix} 2\\1 \end{bmatrix}, \qquad \boldsymbol b= \begin{bmatrix} 0.5\\0 \end{bmatrix}.\]첫 번째 뉴런과 두 번째 뉴런의 입력 합은 각각
\[z_1=0.5\times2+1.0\times1+0.5=2.5, \qquad z_2=-1.0\times2+2.0\times1+0=0\]이므로 $\boldsymbol z=[2.5,0]^T$이다. 각 뉴런의 가중치는 $\boldsymbol W$의 한 행에 들어 있고, 합산 인덱스 $j$는 두 입력을 더한 뒤 사라진다. 자유 인덱스 $i$는 두 뉴런의 출력 위치로 남는다.
W = np.array([[ 0.5, 1.0],
[-1.0, 2.0]])
x = np.array([2.0, 1.0])
b = np.array([0.5, 0.0])
z_matmul = W @ x + b
z_einsum = np.einsum('ij,j->i', W, x) + b
print(z_matmul) # [2.5 0. ]
print(np.allclose(z_matmul, z_einsum)) # True
ANN에서는 이 값에 활성화 함수(activation function)를 적용한다. 예를 들어 ReLU는 음수는 0으로 바꾸고 0 이상은 그대로 두므로 y = np.maximum(0, z_matmul)의 결과도 이 예제에서는 [2.5, 0.0]이다. 여기서 핵심은 새로운 행렬 연산이 아니라, 12장의 행렬–벡터곱과 13장의 'ij,j->i' 표현이 ANN 한 층의 기본 계산에 그대로 사용된다는 점이다.
einsum에서는 -> 뒤에 결과에 남길 인덱스를 적는다.@를 사용하고, 인덱스 표현과 비교할 때 einsum을 활용한다.