게으른 계산: MLX는 왜 계산을 미룰까

목차
  1. 정말 계산을 안 할까: 시간 재 보기
    1. 메모리로도 확인할 수 있다
  2. 계산 그래프: 주문서의 정체
  3. 쓰지 않는 결과는 계산하지 않는다
  4. 계산이 저절로 일어나는 순간
  5. mx.eval은 언제 불러야 할까
    1. 여러 배열을 한 번에 eval하기
  6. 정리
  7. 다음 편
  8. 참고

MLX에서 c = a @ b라고 쓰면, 그 줄에서는 곱셈을 하지 않는다. 공식 문서는 이렇게 말한다.

MLX에서 연산을 해도 실제 계산은 일어나지 않는다. 대신 계산 그래프가 기록된다. 실제 계산은 eval을 할 때만 일어난다.

이것을 게으른 계산(lazy evaluation)이라고 한다.

식당 주문서를 떠올리면 쉽다. 손님이 주문할 때마다 바로 요리하지 않고, 주문서에 적어 두었다가 “이제 내 주세요” 하는 순간 한꺼번에 요리한다. c = a @ b는 주문서에 적는 것이고, mx.eval(c)가 “내 주세요”다.

이 글의 결과는 모두 M4 Mac, MLX 0.32.4에서 실행한 것이다. 걸린 시간은 실행할 때마다 조금씩 달라진다.

정말 계산을 안 할까: 시간 재 보기

4000 × 4000 크기 표 두 개를 곱해 보자. 숫자가 1600만 개씩 들어 있는 큰 계산이다.

import time
import mlx.core as mx

a = mx.random.normal((4000, 4000))
b = mx.random.normal((4000, 4000))
mx.eval(a, b)

t0 = time.perf_counter()
c = a @ b
t1 = time.perf_counter()
mx.eval(c)
t2 = time.perf_counter()
mx.eval(c)
t3 = time.perf_counter()

print(f"c = a @ b  : {(t1 - t0) * 1000:.3f} ms")
print(f"mx.eval(c) : {(t2 - t1) * 1000:.3f} ms")
print(f"한 번 더   : {(t3 - t2) * 1000:.3f} ms")
c = a @ b  : 0.049 ms
mx.eval(c) : 146.062 ms
한 번 더   : 0.024 ms

같은 코드를 한 번 더 실행했을 때는 mx.eval(c)가 42.791 ms였다. 숫자는 달라도 모양은 같다.

  • c = a @ b 줄은 거의 0초다. 곱셈을 하지 않고 “곱하기로 했다”고 적어만 뒀기 때문이다.
  • 시간이 걸리는 곳은 mx.eval(c)다. 여기서 진짜 곱셈을 한다.
  • 이미 계산한 c에 mx.eval을 또 부르면 아무 일도 하지 않는다. 공식 문서도 같은 배열에 eval을 여러 번 불러도 괜찮고, 사실상 아무 일도 안 한다고 설명한다.

앞에서 mx.eval(a, b)를 먼저 부른 이유도 같다. mx.random.normal도 바로 숫자를 만들지 않는다. 미리 만들어 두지 않으면 곱셈 시간에 무작위 숫자 만드는 시간까지 섞인다.

메모리로도 확인할 수 있다

mx.get_active_memory()는 MLX가 지금 쓰고 있는 메모리(바이트)를 알려 준다.

import mlx.core as mx

def mb():
    return mx.get_active_memory() / 1e6

x = mx.ones((1000, 1000))
print(f"만든 직후 : {mb():.1f} MB")
mx.eval(x)
print(f"eval 후   : {mb():.1f} MB")
만든 직후 : 0.0 MB
eval 후   : 4.0 MB

float32 숫자 하나는 4바이트다. 100만 개면 4 MB다. mx.ones를 부른 직후에는 메모리를 하나도 쓰지 않았다. eval을 해야 비로소 숫자를 담을 자리가 생긴다.

계산 그래프: 주문서의 정체

MLX가 “적어 둔다”는 것은 계산 그래프(compute graph)를 만든다는 뜻이다. 계산 그래프는 “어떤 값에 어떤 계산을 해서 무엇을 만드는지” 이어 놓은 순서도다.

d = (a + b) * 2

이 한 줄은 이런 순서도가 된다.

a ─┐
   ├─ 더하기 ─┐
b ─┘          ├─ 곱하기 → d
         2 ───┘

eval을 하면 MLX는 이 순서도를 따라가며 계산한다. 공식 문서는 게으른 계산의 좋은 점을 두 가지 든다.

  1. 계산 그래프를 바꿀 수 있다. 계산하기 전에 순서도가 있으니, 5편에서 배울 mx.grad(자동 미분) 같은 기능이 이 순서도를 보고 일한다.
  2. 쓰는 것만 계산한다. 다음 절에서 직접 확인한다.

쓰지 않는 결과는 계산하지 않는다

결과를 두 개 돌려주는 함수가 있다. 하나는 가볍고, 하나는 무겁다.

import time
import mlx.core as mx

x = mx.random.normal((4000, 4000))
mx.eval(x)

def fun(x):
    small = x.sum()
    big = x @ x @ x @ x
    return small, big

t0 = time.perf_counter()
small, _ = fun(x)
mx.eval(small)
t1 = time.perf_counter()
small, big = fun(x)
mx.eval(small, big)
t2 = time.perf_counter()
print(f"small만  : {(t1 - t0) * 1000:.1f} ms")
print(f"둘 다    : {(t2 - t1) * 1000:.1f} ms")
small만  : 2.1 ms
둘 다    : 125.7 ms

첫 번째는 big을 _로 버리고 small만 eval했다. 그러자 무거운 곱셈 세 번을 아예 하지 않았다. 그래서 60배쯤 빠르다.

공식 문서는 이 방법을 조심해서 쓰라고 한다. big은 계산되지 않지만, big의 계산 그래프는 여전히 만들어지고, 그것에도 비용이 든다.

계산이 저절로 일어나는 순간

지금까지 1편과 2편에서는 mx.eval 없이도 결과가 잘 나왔다. print가 계산을 시켰기 때문이다. 공식 문서에 따르면 아래 경우에 계산이 저절로 일어난다.

하는 일 예
배열을 출력할 때 print(x)
NumPy 배열로 바꿀 때 np.array(x)
memoryview로 메모리에 접근할 때 memoryview(x)
파일로 저장할 때 mx.save("x.npy", x)
숫자 하나를 꺼낼 때 x.item()
숫자 하나짜리 배열을 조건문에 쓸 때 if x > 0:

print가 계산을 시키는지 메모리로 확인해 보자. print는 안에서 str(x)로 글자를 만든다.

import mlx.core as mx

def mb():
    return mx.get_active_memory() / 1e6

x = mx.ones((1000, 1000))
print(f"만든 직후  : {mb():.1f} MB")
s = str(x)  # print가 하는 일과 같다
print(f"str(x) 후  : {mb():.1f} MB")
만든 직후  : 0.0 MB
str(x) 후  : 4.0 MB

mx.eval을 부르지 않았는데도 메모리가 4 MB가 됐다. 글자로 바꾸려면 숫자가 있어야 하니 계산을 한 것이다.

조건문과 .item()도 해 보자.

import mlx.core as mx

y = mx.array([1, 2, 3]) * 2
print(type(y.sum() > 5))
if y.sum() > 5:
    print("5보다 크다")

v = y.sum().item()
print(v, type(v))
<class 'mlx.core.array'>
5보다 크다
12 <class 'int'>

y.sum() > 5는 True가 아니라 MLX 배열이다. if는 참인지 거짓인지 알아야 하니, 그 자리에서 계산을 한다.

공식 문서는 숫자 하나짜리 배열을 조건문에 쓰면 계산이 일어난다고 경고한다. 코드는 맞게 돌아가지만, 이런 계산이 너무 자주 일어나면 아주 느려질 수 있다.

mx.eval은 언제 불러야 할까

공식 문서는 이것을 저울질이라고 설명한다.

  • 너무 자주 부르면 손해다. eval을 한 번 할 때마다 정해진 준비 비용이 든다.
  • 너무 안 부르면 그래프가 아주 커진다. 그래프 크기에 따라 늘어나는 작은 비용이 있어서, 아주 큰 그래프도 비용이 크다.

덧셈 1000번을 하는 반복문으로 비교해 보자. 한쪽은 매번 eval하고, 다른 쪽은 마지막에 한 번만 한다.

import time
import mlx.core as mx

def run(every_step):
    a = mx.zeros((100,))
    b = mx.ones((100,))
    t0 = time.perf_counter()
    for _ in range(1000):
        a = a + b
        if every_step:
            mx.eval(a)
    mx.eval(a)
    ms = (time.perf_counter() - t0) * 1000
    return f"{ms:.1f} ms, a[0] = {a[0].item()}"

run(True)  # 첫 실행 준비
for _ in range(3):
    print("매번 eval :", run(True))
    print("마지막만  :", run(False))
매번 eval : 177.8 ms, a[0] = 1000.0
마지막만  : 2.5 ms, a[0] = 1000.0
매번 eval : 181.3 ms, a[0] = 1000.0
마지막만  : 2.2 ms, a[0] = 1000.0
매번 eval : 168.3 ms, a[0] = 1000.0
마지막만  : 2.1 ms, a[0] = 1000.0

결과(a[0] = 1000.0)는 똑같다. 그런데 매번 eval한 쪽이 70배쯤 느리다. 덧셈 하나는 아주 작은 일이라, 일보다 eval의 준비 비용이 훨씬 컸다.

그렇다고 끝없이 미루면 안 된다. 공식 문서가 주는 기준은 이렇다.

  • eval 한 번에 수십 개에서 수천 개 연산까지는 잘 동작한다.
  • 숫자 계산에는 바깥 반복문이 있다. 모델 학습이라면 “데이터 한 묶음마다 한 번” 도는 반복문이다. 이 바깥 반복문 한 바퀴마다 eval을 한 번 부르는 것이 자연스럽다.

위 반복문에서 덧셈을 100만 번 하면서 마지막에만 eval하면 어떻게 될까? 그래프에 연산이 100만 개 쌓인다. 공식 문서가 말한 “수천 개”를 훨씬 넘는다.

여러 배열을 한 번에 eval하기

mx.eval에는 배열 여러 개를 한꺼번에 넘길 수 있다. 딕셔너리나 리스트로 묶어서 넘겨도 된다. 배열이 아닌 값은 그냥 건너뛴다.

y = mx.array([1, 2, 3]) * 2
params = {"w": y + 1, "b": [y * 10, "메모"]}
mx.eval(params)
print(params)
{'w': array([3, 5, 7], dtype=int32), 'b': [array([20, 40, 60], dtype=int32), '메모']}

mlx.nn 모델의 parameters()도 딕셔너리를 돌려준다. 그래서 공식 문서의 학습 예제는 반복문 한 바퀴마다 mx.eval(loss, model.parameters())로 손실과 가중치를 한 번에 계산한다.

정리

  • MLX는 연산을 하면 바로 계산하지 않고 계산 그래프에 적어 둔다.
  • 실제 계산은 mx.eval을 할 때 일어난다. 계산 전에는 메모리도 쓰지 않는다.
  • 쓰지 않는 결과는 계산하지 않는다. 다만 그래프를 만드는 비용은 든다.
  • print, NumPy 변환, 저장, .item(), 조건문은 계산을 저절로 시킨다.
  • eval을 너무 자주 부르면 느리다. 바깥 반복문 한 바퀴마다 한 번이 기준이다.
  • 같은 배열에 eval을 여러 번 불러도 괜찮다. 두 번째부터는 아무 일도 안 한다.

다음 편

1편에서 Apple 실리콘은 CPU와 GPU가 같은 메모리를 함께 쓴다고 했다. 다음 편에서는 이 통합 메모리가 MLX에서 무슨 뜻인지, 그리고 계산을 CPU와 GPU 중 어디서 할지 고르는 방법을 다룬다.

참고