상위 목록: 하위 목록: 작성 날짜: 읽는 데 5 분 소요

아인슈타인 합(Einsum)

import numpy as np

a = np.array([
    [1, 2, 3],
    [4, 5, 6]
])

print(np.einsum("ij->", a))
print(np.einsum("ij->j", a))
print(np.einsum("ij->i", a))
print(np.einsum("ij->ji", a))
결과
21
[5 7 9]
[ 6 15]
[[1 4]
 [2 5]
 [3 6]]

아인슈타인 합 함수(np.einsum)는 배열의 각 축에 알파벳 첨자를 붙여, 합계, 전치, 행렬 곱 등의 연산을 하나의 문자열로 표현합니다.

np.einsum("입력 첨자->출력 첨자", 배열)로 계산하며, 이 표기법은 물리학자 아인슈타인이 텐서 계산을 간단히 쓰기 위해 사용한 아인슈타인 표기법(Einstein Notation)에서 유래했습니다.

규칙은 다음 두 가지입니다.

  • 입력에는 있지만 출력에 없는 첨자는 그 축을 따라 합산되어 사라집니다.
  • 출력에 남은 첨자는 출력에 적힌 순서대로 결과 배열의 축이 됩니다.


예제의 (2, 3) 배열에서 i는 행 축, j는 열 축입니다.

"ij->"는 출력 첨자가 없으므로 모든 축을 합산해 전체 합 21을 반환합니다. "ij->j"는 i가 사라지므로 행 방향으로 합산한 열별 합, "ij->i"는 행별 합이 됩니다. 7강의 np.sum(a, axis=0), np.sum(a, axis=1)과 같은 결과입니다.

"ij->ji"는 사라지는 첨자 없이 순서만 바뀌므로 전치가 됩니다.



두 배열의 연산

import numpy as np

a = np.array([
    [1, 2],
    [3, 4]
])
b = np.array([
    [5, 6],
    [7, 8]
])

print(np.einsum("ik,kj->ij", a, b))
print(a @ b)
print(np.einsum("ij,ij->ij", a, b))
print(np.einsum("ij,ij->", a, b))
결과
[[19 22]
 [43 50]]
[[19 22]
 [43 50]]
[[ 5 12]
 [21 32]]
70

여러 배열을 입력할 때는 각 배열의 첨자를 쉼표로 구분합니다.

같은 첨자가 서로 다른 배열에 등장하면, 두 배열에서 그 첨자의 위치가 같은 원소끼리 곱합니다. 이후 출력에 없는 첨자는 합산합니다.

"ik,kj->ij"는 a의 열과 b의 행이 같은 첨자 k를 가지므로, k를 따라 곱한 값을 합산합니다. 즉, 결과의 (i, j) 원소는 \(\sum_k a_{ik} b_{kj}\)이며, 이는 8강의 행렬 곱과 같습니다. 예제의 첫 번째 원소는 1 × 5 + 2 × 7 = 19입니다.

"ij,ij->ij"는 두 배열의 첨자가 모두 같고 사라지는 첨자가 없으므로 원소별 곱이 됩니다. a * b와 같습니다.

"ij,ij->"는 원소별 곱을 모두 합산하므로 5 + 12 + 21 + 32 = 70이 됩니다.



벡터와 대각 연산

import numpy as np

u = np.array([1, 2, 3])
v = np.array([4, 5, 6])
m = np.array([
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
])

print(np.einsum("i,i->", u, v))
print(np.einsum("i,j->ij", u, v))
print(np.einsum("ij,j->i", m, u))
print(np.einsum("ii->", m))
print(np.einsum("ii->i", m))
결과
32
[[ 4  5  6]
 [ 8 10 12]
 [12 15 18]]
[14 32 50]
15
[1 5 9]

"i,i->"는 같은 위치의 원소를 곱해 합산하므로 내적(Dot Product)이 됩니다. 1 × 4 + 2 × 5 + 3 × 6 = 32입니다.

"i,j->ij"는 두 벡터가 서로 다른 첨자를 가지므로 곱할 위치가 겹치지 않고, 모든 조합의 곱이 출력에 남습니다. 이를 외적(Outer Product)이라 하며, np.outer(u, v)와 같습니다.

"ij,j->i"는 행렬의 각 행과 벡터의 내적으로, 행렬과 벡터의 곱 m @ u와 같습니다.

하나의 배열에 같은 첨자가 두 번 등장하면, 두 축의 색인이 같은 원소, 즉 대각 성분만 선택됩니다.

"ii->"는 대각 성분을 합산하므로 8강의 np.trace와 같은 1 + 5 + 9 = 15를 반환하고, "ii->i"는 대각 성분을 배열로 반환하므로 np.diag(m)과 같습니다.



출력 첨자 생략(Implicit Mode)

import numpy as np

a = np.array([
    [1, 2],
    [3, 4]
])
b = np.array([
    [5, 6],
    [7, 8]
])

print(np.einsum("ij,jk", a, b))
print(np.einsum("ij", a))
print(np.einsum("ji", a))
print(np.einsum("ij,ij", a, b))
결과
[[19 22]
 [43 50]]
[[1 2]
 [3 4]]
[[1 3]
 [2 4]]
70

->와 출력 첨자를 생략하면 암시적 모드(Implicit Mode)로 동작합니다.

암시적 모드에서는 한 번만 등장한 첨자가 출력으로 남고, 두 번 이상 등장한 첨자는 합산됩니다. 출력 첨자의 순서는 알파벳 순서로 정해집니다.

"ij,jk"는 j가 두 번 등장하므로 합산되고, i와 k가 남아 "ij,jk->ik", 즉 행렬 곱이 됩니다.

"ij"는 출력이 알파벳 순서인 ij가 되므로 배열이 그대로 반환되지만, "ji"는 출력이 ij로 정렬되므로 입력의 두 축이 바뀌어 전치가 됩니다.

"ij,ij"는 i와 j가 모두 두 번 등장하므로 모두 합산되어 70이 됩니다.

  • Tip : 암시적 모드는 짧게 쓸 수 있지만, 알파벳 순서 규칙 때문에 결과의 축 순서를 착각하기 쉽습니다. 코드를 읽는 사람을 위해 ->와 출력 첨자를 명시하는 것을 권장합니다.



배치 연산(Batch Operation)

import numpy as np

rng = np.random.default_rng(0)
a = rng.random((10, 3, 4))
b = rng.random((10, 4, 5))

c = np.einsum("bij,bjk->bik", a, b)
print(c.shape)
print(np.allclose(c, a @ b))

x = rng.random((10, 4))
y = rng.random((10, 4))
print(np.einsum("bi,bi->b", x, y).shape)
결과
(10, 3, 5)
True
(10,)

np.einsum은 여러 개의 행렬을 묶은 배치(Batch) 연산을 간단히 표현할 수 있습니다.

"bij,bjk->bik"는 첨자 b가 출력에도 남아 있으므로 합산되지 않고, b마다 독립적인 행렬 곱을 수행합니다. 예제는 (3, 4) 행렬과 (4, 5) 행렬의 곱을 10번 계산해 (10, 3, 5) 배열을 반환하며, a @ b와 같은 결과입니다.

np.allclose는 두 배열의 모든 원소가 허용 오차 안에서 같은지 확인합니다. 실수 연산은 계산 순서에 따라 아주 작은 오차가 생길 수 있으므로, 실수 배열을 비교할 때는 == 대신 사용합니다.

"bi,bi->b"는 배치마다 두 벡터의 내적을 계산합니다. np.sum(x * y, axis=1)과 같지만, 곱한 결과를 담는 중간 배열을 만들지 않습니다.

  • Tip : 딥러닝의 어텐션 점수처럼 (배치, 헤드, 길이, 차원) 형태의 배열을 다룰 때는 "bhqd,bhkd->bhqk"처럼 각 축의 의미를 첨자로 드러내면 코드를 읽기 쉬워집니다. PyTorch의 torch.einsum도 같은 표기법을 사용합니다.



나머지 축 생략(Ellipsis)

import numpy as np

rng = np.random.default_rng(0)
image = rng.random((2, 32, 32, 3))
weight = np.array([0.299, 0.587, 0.114])

gray = np.einsum("...c,c->...", image, weight)
print(gray.shape)

x = rng.random((5, 6, 3, 4))
print(np.einsum("...ij->...ji", x).shape)
결과
(2, 32, 32)
(5, 6, 4, 3)

...은 첨자를 붙이지 않은 나머지 축 전체를 의미합니다. 축의 개수가 정해지지 않았거나 많을 때, 관심 있는 축에만 첨자를 붙일 수 있습니다.

"...c,c->..."는 마지막 축 c를 가중치와 곱해 합산하고, 앞의 축은 그대로 유지합니다. 예제는 (이미지 수, 높이, 너비, 채널) 형태의 컬러 이미지를 채널별 가중치로 합산해 흑백 이미지로 변환합니다.

"...ij->...ji"는 앞의 축은 유지하고 마지막 두 축만 전치합니다. 입력 배열이 3차원이든 4차원이든 같은 문자열로 동작합니다.



계산 순서 최적화(Optimize)

import numpy as np

rng = np.random.default_rng(0)
a = rng.random((100, 200))
b = rng.random((200, 300))
c = rng.random((300, 10))

path, info = np.einsum_path("ij,jk,kl->il", a, b, c, optimize="optimal")
print(path)

r1 = np.einsum("ij,jk,kl->il", a, b, c, optimize=True)
r2 = a @ (b @ c)
print(np.allclose(r1, r2))
결과
[‘einsum_path’, (1, 2), (0, 1)]
True

세 개 이상의 배열을 연산할 때는 어떤 순서로 계산하느냐에 따라 계산량이 크게 달라집니다.

예제의 행렬 곱 \(ABC\)는 (A @ B) @ C 순서로 계산하면 약 100 × 200 × 300 + 100 × 300 × 10 = 630만 번의 곱셈이 필요합니다. 반면 A @ (B @ C) 순서는 200 × 300 × 10 + 100 × 200 × 10 = 80만 번으로, 약 8분의 1입니다.

np.einsum은 기본적으로(optimize=False) 계산 순서를 최적화하지 않으며, 모든 첨자 i, j, k, l의 조합을 한 번에 순회하므로 100 × 200 × 300 × 10 = 6천만 번의 곱셈이 필요할 수 있습니다.

optimize=True를 지정하면 계산량이 적은 순서를 찾아 두 배열씩 나누어 계산합니다. 가능한 경우 내부적으로 np.matmul 같은 최적화된 함수를 사용하므로 훨씬 빠릅니다.

np.einsum_path 함수는 실제로 계산하지 않고 계산 순서만 반환합니다. (1, 2)는 1번과 2번 배열인 b와 c를 먼저 계산한다는 의미이며, 계산된 결과는 목록의 끝으로 이동하므로 그다음의 (0, 1)은 a와 그 결과를 계산합니다. 두 번째 반환값인 info를 출력하면 계산량의 비교 정보를 확인할 수 있습니다.

  • Tip : 두 배열의 단순한 행렬 곱이라면 @ 연산자가 가장 빠르고 의도도 분명합니다. np.einsum은 축이 많거나, 배치와 전치와 합산이 함께 필요한 연산처럼 다른 함수로 표현하기 번거로운 경우에 사용합니다.



아인슈타인 합 정리

첨자 표기 연산 같은 함수
ij-> 전체 합 np.sum(a)
ij->j 열별 합 np.sum(a, axis=0)
ij->ji 전치 a.T
ii-> 대각합 np.trace(a)
ii->i 대각 성분 np.diag(a)
i,i-> 내적 np.dot(u, v)
i,j->ij 외적 np.outer(u, v)
ij,j->i 행렬과 벡터의 곱 a @ u
ik,kj->ij 행렬 곱 a @ b
ij,ij->ij 원소별 곱 a * b
bij,bjk->bik 배치 행렬 곱 a @ b
…ij->…ji 마지막 두 축 전치 np.swapaxes(a, -1, -2)


  • Tip : 첨자를 정할 때는 출력에 남는 축과 합산되어 사라지는 축을 먼저 구분합니다. 출력에 없는 첨자가 곧 합산할 축입니다.

댓글 남기기